src/compiler/target-disassem.lisp

   1 ;;;; disassembler-related stuff not needed in cross-compilation host
   2
   3 ;;;; This software is part of the SBCL system. See the README file for
   4 ;;;; more information.
   5 ;;;;
   6 ;;;; This software is derived from the CMU CL system, which was
   7 ;;;; written at Carnegie Mellon University and released into the
   8 ;;;; public domain. The software is in the public domain and is
   9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
  10 ;;;; files for more information.
  11
  12 (in-package "SB!DISASSEM")
  13
  14 ;;;; FIXME: A lot of stupid package prefixes would go away if DISASSEM
  15 ;;;; would use the SB!DI package. And some more would go away if it would
  16 ;;;; use SB!SYS (in order to get to the SAP-FOO operators).
  17 \f
  18 ;;;; combining instructions where one specializes another
  19
  20 ;;; Return non-NIL if the instruction SPECIAL is a more specific
  21 ;;; version of GENERAL (i.e., the same instruction, but with more
  22 ;;; constraints).
  23 (defun inst-specializes-p (special general)
  24   (declare (type instruction special general))
  25   (let ((smask (inst-mask special))
  26         (gmask (inst-mask general)))
  27     (and (dchunk= (inst-id general)
  28                   (dchunk-and (inst-id special) gmask))
  29          (dchunk-strict-superset-p smask gmask))))
  30
  31 ;;; a bit arbitrary, but should work ok...
  32 ;;;
  33 ;;; Return an integer corresponding to the specificity of the
  34 ;;; instruction INST.
  35 (defun specializer-rank (inst)
  36   (declare (type instruction inst))
  37   (* (dchunk-count-bits (inst-mask inst)) 4))
  38
  39 ;;; Order the list of instructions INSTS with more specific (more
  40 ;;; constant bits, or same-as argument constains) ones first. Returns
  41 ;;; the ordered list.
  42 (defun order-specializers (insts)
  43   (declare (type list insts))
  44   (sort insts #'> :key #'specializer-rank))
  45
  46 (defun specialization-error (insts)
  47   (bug
  48    "~@<Instructions either aren't related or conflict in some way: ~4I~_~S~:>"
  49    insts))
  50
  51 ;;; Given a list of instructions INSTS, Sees if one of these instructions is a
  52 ;;; more general form of all the others, in which case they are put into its
  53 ;;; specializers list, and it is returned. Otherwise an error is signaled.
  54 (defun try-specializing (insts)
  55   (declare (type list insts))
  56   (let ((masters (copy-list insts)))
  57     (dolist (possible-master insts)
  58       (dolist (possible-specializer insts)
  59         (unless (or (eq possible-specializer possible-master)
  60                     (inst-specializes-p possible-specializer possible-master))
  61           (setf masters (delete possible-master masters))
  62           (return)                      ; exit the inner loop
  63           )))
  64     (cond ((null masters)
  65            (specialization-error insts))
  66           ((cdr masters)
  67            (error "multiple specializing masters: ~S" masters))
  68           (t
  69            (let ((master (car masters)))
  70              (setf (inst-specializers master)
  71                    (order-specializers (remove master insts)))
  72              master)))))
  73 \f
  74 ;;;; choosing an instruction
  75
  76 #!-sb-fluid (declaim (inline inst-matches-p choose-inst-specialization))
  77
  78 ;;; Return non-NIL if all constant-bits in INST match CHUNK.
  79 (defun inst-matches-p (inst chunk)
  80   (declare (type instruction inst)
  81            (type dchunk chunk))
  82   (dchunk= (dchunk-and (inst-mask inst) chunk) (inst-id inst)))
  83
  84 ;;; Given an instruction object, INST, and a bit-pattern, CHUNK, pick
  85 ;;; the most specific instruction on INST's specializer list whose
  86 ;;; constraints are met by CHUNK. If none do, then return INST.
  87 (defun choose-inst-specialization (inst chunk)
  88   (declare (type instruction inst)
  89            (type dchunk chunk))
  90   (or (dolist (spec (inst-specializers inst) nil)
  91         (declare (type instruction spec))
  92         (when (inst-matches-p spec chunk)
  93           (return spec)))
  94       inst))
  95 \f
  96 ;;;; searching for an instruction in instruction space
  97
  98 ;;; Return the instruction object within INST-SPACE corresponding to the
  99 ;;; bit-pattern CHUNK, or NIL if there isn't one.
 100 (defun find-inst (chunk inst-space)
 101   (declare (type dchunk chunk)
 102            (type (or null inst-space instruction) inst-space))
 103   (etypecase inst-space
 104     (null nil)
 105     (instruction
 106      (if (inst-matches-p inst-space chunk)
 107          (choose-inst-specialization inst-space chunk)
 108          nil))
 109     (inst-space
 110      (let* ((mask (ispace-valid-mask inst-space))
 111             (id (dchunk-and mask chunk)))
 112        (declare (type dchunk id mask))
 113        (dolist (choice (ispace-choices inst-space))
 114          (declare (type inst-space-choice choice))
 115          (when (dchunk= id (ischoice-common-id choice))
 116            (return (find-inst chunk (ischoice-subspace choice)))))))))
 117 \f
 118 ;;;; building the instruction space
 119
 120 ;;; Returns an instruction-space object corresponding to the list of
 121 ;;; instructions INSTS. If the optional parameter INITIAL-MASK is
 122 ;;; supplied, only bits it has set are used.
 123 (defun build-inst-space (insts &optional (initial-mask dchunk-one))
 124   ;; This is done by finding any set of bits that's common to
 125   ;; all instructions, building an instruction-space node that selects on those
 126   ;; bits, and recursively handle sets of instructions with a common value for
 127   ;; these bits (which, since there should be fewer instructions than in INSTS,
 128   ;; should have some additional set of bits to select on, etc). If there
 129   ;; are no common bits, or all instructions have the same value within those
 130   ;; bits, TRY-SPECIALIZING is called, which handles the cases of many
 131   ;; variations on a single instruction.
 132   (declare (type list insts)
 133            (type dchunk initial-mask))
 134   (cond ((null insts)
 135          nil)
 136         ((null (cdr insts))
 137          (car insts))
 138         (t
 139          (let ((vmask (dchunk-copy initial-mask)))
 140            (dolist (inst insts)
 141              (dchunk-andf vmask (inst-mask inst)))
 142            (if (dchunk-zerop vmask)
 143                (try-specializing insts)
 144                (let ((buckets nil))
 145                  (dolist (inst insts)
 146                    (let* ((common-id (dchunk-and (inst-id inst) vmask))
 147                           (bucket (assoc common-id buckets :test #'dchunk=)))
 148                      (cond ((null bucket)
 149                             (push (list common-id inst) buckets))
 150                            (t
 151                             (push inst (cdr bucket))))))
 152                  (let ((submask (dchunk-clear initial-mask vmask)))
 153                    (if (= (length buckets) 1)
 154                        (try-specializing insts)
 155                        (make-inst-space
 156                         :valid-mask vmask
 157                         :choices (mapcar (lambda (bucket)
 158                                            (make-inst-space-choice
 159                                             :subspace (build-inst-space
 160                                                        (cdr bucket)
 161                                                        submask)
 162                                             :common-id (car bucket)))
 163                                          buckets))))))))))
 164 \f
 165 ;;;; an inst-space printer for debugging purposes
 166
 167 (defun print-masked-binary (num mask word-size &optional (show word-size))
 168   (do ((bit (1- word-size) (1- bit)))
 169       ((< bit 0))
 170     (write-char (cond ((logbitp bit mask)
 171                        (if (logbitp bit num) #\1 #\0))
 172                       ((< bit show) #\x)
 173                       (t #\space)))))
 174
 175 (defun print-inst-bits (inst)
 176   (print-masked-binary (inst-id inst)
 177                        (inst-mask inst)
 178                        dchunk-bits
 179                        (bytes-to-bits (inst-length inst))))
 180
 181 ;;; Print a nicely-formatted version of INST-SPACE.
 182 (defun print-inst-space (inst-space &optional (indent 0))
 183   (etypecase inst-space
 184     (null)
 185     (instruction
 186      (format t "~Vt[~A(~A)~40T" indent
 187              (inst-name inst-space)
 188              (inst-format-name inst-space))
 189      (print-inst-bits inst-space)
 190      (dolist (inst (inst-specializers inst-space))
 191        (format t "~%~Vt:~A~40T" indent (inst-name inst))
 192        (print-inst-bits inst))
 193      (write-char #\])
 194      (terpri))
 195     (inst-space
 196      (format t "~Vt---- ~8,'0X ----~%"
 197              indent
 198              (ispace-valid-mask inst-space))
 199      (map nil
 200           (lambda (choice)
 201             (format t "~Vt~8,'0X ==>~%"
 202                     (+ 2 indent)
 203                     (ischoice-common-id choice))
 204             (print-inst-space (ischoice-subspace choice)
 205                               (+ 4 indent)))
 206           (ispace-choices inst-space)))))
 207 \f
 208 ;;;; (The actual disassembly part follows.)
 209 \f
 210 ;;; Code object layout:
 211 ;;;     header-word
 212 ;;;     code-size (starting from first inst, in words)
 213 ;;;     entry-points (points to first function header)
 214 ;;;     debug-info
 215 ;;;     trace-table-offset (starting from first inst, in bytes)
 216 ;;;     constant1
 217 ;;;     constant2
 218 ;;;     ...
 219 ;;;     <padding to dual-word boundary>
 220 ;;;     start of instructions
 221 ;;;     ...
 222 ;;;     fun-headers and lra's buried in here randomly
 223 ;;;     ...
 224 ;;;     start of trace-table
 225 ;;;     <padding to dual-word boundary>
 226 ;;;
 227 ;;; Function header layout (dual word aligned):
 228 ;;;     header-word
 229 ;;;     self pointer
 230 ;;;     next pointer (next function header)
 231 ;;;     name
 232 ;;;     arglist
 233 ;;;     type
 234 ;;;
 235 ;;; LRA layout (dual word aligned):
 236 ;;;     header-word
 237
 238 #!-sb-fluid (declaim (inline words-to-bytes bytes-to-words))
 239
 240 (eval-when (:compile-toplevel :load-toplevel :execute)
 241   ;;; Convert a word-offset NUM to a byte-offset.
 242   (defun words-to-bytes (num)
 243     (declare (type offset num))
 244     (ash num sb!vm:word-shift))
 245   ) ; EVAL-WHEN
 246
 247 ;;; Convert a byte-offset NUM to a word-offset.
 248 (defun bytes-to-words (num)
 249   (declare (type offset num))
 250   (ash num (- sb!vm:word-shift)))
 251
 252 (defconstant lra-size (words-to-bytes 1))
 253 \f
 254 (defstruct (offs-hook (:copier nil))
 255   (offset 0 :type offset)
 256   (fun (missing-arg) :type function)
 257   (before-address nil :type (member t nil)))
 258
 259 (defstruct (segment (:conc-name seg-)
 260                     (:constructor %make-segment)
 261                     (:copier nil))
 262   (sap-maker (missing-arg)
 263              :type (function () sb!sys:system-area-pointer))
 264   (length 0 :type length)
 265   (virtual-location 0 :type address)
 266   (storage-info nil :type (or null storage-info))
 267   (code nil :type (or null sb!kernel:code-component))
 268   (hooks nil :type list))
 269 (def!method print-object ((seg segment) stream)
 270   (print-unreadable-object (seg stream :type t)
 271     (let ((addr (sb!sys:sap-int (funcall (seg-sap-maker seg)))))
 272       (format stream "#X~X[~W]~:[ (#X~X)~;~*~]~@[ in ~S~]"
 273               addr
 274               (seg-length seg)
 275               (= (seg-virtual-location seg) addr)
 276               (seg-virtual-location seg)
 277               (seg-code seg)))))
 278 \f
 279 ;;; All state during disassembly. We store some seemingly redundant
 280 ;;; information so that we can allow garbage collect during disassembly and
 281 ;;; not get tripped up by a code block being moved...
 282 (defstruct (disassem-state (:conc-name dstate-)
 283                            (:constructor %make-dstate)
 284                            (:copier nil))
 285   ;; offset of current pos in segment
 286   (cur-offs 0 :type offset)
 287   ;; offset of next position
 288   (next-offs 0 :type offset)
 289   ;; a sap pointing to our segment
 290   (segment-sap (missing-arg) :type sb!sys:system-area-pointer)
 291   ;; the current segment
 292   (segment nil :type (or null segment))
 293   ;; what to align to in most cases
 294   (alignment sb!vm:n-word-bytes :type alignment)
 295   (byte-order :little-endian
 296               :type (member :big-endian :little-endian))
 297   ;; for user code to hang stuff off of
 298   (properties nil :type list)
 299   (filtered-values (make-array max-filtered-value-index)
 300                    :type filtered-value-vector)
 301   ;; used for prettifying printing
 302   (addr-print-len nil :type (or null (integer 0 20)))
 303   (argument-column 0 :type column)
 304   ;; to make output look nicer
 305   (output-state :beginning
 306                 :type (member :beginning
 307                               :block-boundary
 308                               nil))
 309
 310   ;; alist of (address . label-number)
 311   (labels nil :type list)
 312   ;; same as LABELS slot data, but in a different form
 313   (label-hash (make-hash-table) :type hash-table)
 314   ;; list of function
 315   (fun-hooks nil :type list)
 316
 317   ;; alist of (address . label-number), popped as it's used
 318   (cur-labels nil :type list)
 319   ;; OFFS-HOOKs, popped as they're used
 320   (cur-offs-hooks nil :type list)
 321
 322   ;; for the current location
 323   (notes nil :type list)
 324
 325   ;; currently active source variables
 326   (current-valid-locations nil :type (or null (vector bit))))
 327 (def!method print-object ((dstate disassem-state) stream)
 328   (print-unreadable-object (dstate stream :type t)
 329     (format stream
 330             "+~W~@[ in ~S~]"
 331             (dstate-cur-offs dstate)
 332             (dstate-segment dstate))))
 333
 334 ;;; Return the absolute address of the current instruction in DSTATE.
 335 (defun dstate-cur-addr (dstate)
 336   (the address (+ (seg-virtual-location (dstate-segment dstate))
 337                   (dstate-cur-offs dstate))))
 338
 339 ;;; Return the absolute address of the next instruction in DSTATE.
 340 (defun dstate-next-addr (dstate)
 341   (the address (+ (seg-virtual-location (dstate-segment dstate))
 342                   (dstate-next-offs dstate))))
 343 \f
 344 ;;;; function ops
 345
 346 (defun fun-self (fun)
 347   (declare (type compiled-function fun))
 348   (sb!kernel:%simple-fun-self fun))
 349
 350 (defun fun-code (fun)
 351   (declare (type compiled-function fun))
 352   (sb!kernel:fun-code-header (fun-self fun)))
 353
 354 (defun fun-next (fun)
 355   (declare (type compiled-function fun))
 356   (sb!kernel:%simple-fun-next fun))
 357
 358 (defun fun-address (function)
 359   (declare (type compiled-function function))
 360   (- (sb!kernel:get-lisp-obj-address function) sb!vm:fun-pointer-lowtag))
 361
 362 ;;; the offset of FUNCTION from the start of its code-component's
 363 ;;; instruction area
 364 (defun fun-insts-offset (function)
 365   (declare (type compiled-function function))
 366   (- (fun-address function)
 367      (sb!sys:sap-int (sb!kernel:code-instructions (fun-code function)))))
 368
 369 ;;; the offset of FUNCTION from the start of its code-component
 370 (defun fun-offset (function)
 371   (declare (type compiled-function function))
 372   (words-to-bytes (sb!kernel:get-closure-length function)))
 373 \f
 374 ;;;; operations on code-components (which hold the instructions for
 375 ;;;; one or more functions)
 376
 377 ;;; Return the length of the instruction area in CODE-COMPONENT.
 378 (defun code-inst-area-length (code-component)
 379   (declare (type sb!kernel:code-component code-component))
 380   (sb!kernel:code-header-ref code-component
 381                              sb!vm:code-trace-table-offset-slot))
 382
 383 ;;; Return the address of the instruction area in CODE-COMPONENT.
 384 (defun code-inst-area-address (code-component)
 385   (declare (type sb!kernel:code-component code-component))
 386   (sb!sys:sap-int (sb!kernel:code-instructions code-component)))
 387
 388 ;;; unused as of sbcl-0.pre7.129
 389 #|
 390 ;;; Return the first function in CODE-COMPONENT.
 391 (defun code-first-function (code-component)
 392   (declare (type sb!kernel:code-component code-component))
 393   (sb!kernel:code-header-ref code-component
 394                              sb!vm:code-trace-table-offset-slot))
 395 |#
 396
 397 (defun segment-offs-to-code-offs (offset segment)
 398   (sb!sys:without-gcing
 399    (let* ((seg-base-addr (sb!sys:sap-int (funcall (seg-sap-maker segment))))
 400           (code-addr
 401            (logandc1 sb!vm:lowtag-mask
 402                      (sb!kernel:get-lisp-obj-address (seg-code segment))))
 403           (addr (+ offset seg-base-addr)))
 404      (declare (type address seg-base-addr code-addr addr))
 405      (- addr code-addr))))
 406
 407 (defun code-offs-to-segment-offs (offset segment)
 408   (sb!sys:without-gcing
 409    (let* ((seg-base-addr (sb!sys:sap-int (funcall (seg-sap-maker segment))))
 410           (code-addr
 411            (logandc1 sb!vm:lowtag-mask
 412                      (sb!kernel:get-lisp-obj-address (seg-code segment))))
 413           (addr (+ offset code-addr)))
 414      (declare (type address seg-base-addr code-addr addr))
 415      (- addr seg-base-addr))))
 416
 417 (defun code-insts-offs-to-segment-offs (offset segment)
 418   (sb!sys:without-gcing
 419    (let* ((seg-base-addr (sb!sys:sap-int (funcall (seg-sap-maker segment))))
 420           (code-insts-addr
 421            (sb!sys:sap-int (sb!kernel:code-instructions (seg-code segment))))
 422           (addr (+ offset code-insts-addr)))
 423      (declare (type address seg-base-addr code-insts-addr addr))
 424      (- addr seg-base-addr))))
 425 \f
 426 (defun lra-hook (chunk stream dstate)
 427   (declare (type dchunk chunk)
 428            (ignore chunk)
 429            (type (or null stream) stream)
 430            (type disassem-state dstate))
 431   (when (and (aligned-p (+ (seg-virtual-location (dstate-segment dstate))
 432                            (dstate-cur-offs dstate))
 433                         (* 2 sb!vm:n-word-bytes))
 434              ;; Check type.
 435              (= (sb!sys:sap-ref-8 (dstate-segment-sap dstate)
 436                                   (if (eq (dstate-byte-order dstate)
 437                                           :little-endian)
 438                                       (dstate-cur-offs dstate)
 439                                       (+ (dstate-cur-offs dstate)
 440                                          (1- lra-size))))
 441                 sb!vm:return-pc-header-widetag))
 442     (unless (null stream)
 443       (princ '.lra stream))
 444     (incf (dstate-next-offs dstate) lra-size))
 445   nil)
 446
 447 ;;; Print the fun-header (entry-point) pseudo-instruction at the
 448 ;;; current location in DSTATE to STREAM.
 449 (defun fun-header-hook (stream dstate)
 450   (declare (type (or null stream) stream)
 451            (type disassem-state dstate))
 452   (unless (null stream)
 453     (let* ((seg (dstate-segment dstate))
 454            (code (seg-code seg))
 455            (woffs
 456             (bytes-to-words
 457              (segment-offs-to-code-offs (dstate-cur-offs dstate) seg)))
 458            (name
 459             (sb!kernel:code-header-ref code
 460                                        (+ woffs
 461                                           sb!vm:simple-fun-name-slot)))
 462            (args
 463             (sb!kernel:code-header-ref code
 464                                        (+ woffs
 465                                           sb!vm:simple-fun-arglist-slot)))
 466            (type
 467             (sb!kernel:code-header-ref code
 468                                        (+ woffs
 469                                           sb!vm:simple-fun-type-slot))))
 470       (format stream ".~A ~S~:A" 'entry name args)
 471       (note (lambda (stream)
 472               (format stream "~:S" type)) ; use format to print NIL as ()
 473             dstate)))
 474   (incf (dstate-next-offs dstate)
 475         (words-to-bytes sb!vm:simple-fun-code-offset)))
 476 \f
 477 (defun alignment-hook (chunk stream dstate)
 478   (declare (type dchunk chunk)
 479            (ignore chunk)
 480            (type (or null stream) stream)
 481            (type disassem-state dstate))
 482   (let ((location
 483          (+ (seg-virtual-location (dstate-segment dstate))
 484             (dstate-cur-offs dstate)))
 485         (alignment (dstate-alignment dstate)))
 486     (unless (aligned-p location alignment)
 487       (when stream
 488         (format stream "~A~Vt~W~%" '.align
 489                 (dstate-argument-column dstate)
 490                 alignment))
 491       (incf(dstate-next-offs dstate)
 492            (- (align location alignment) location)))
 493     nil))
 494
 495 (defun rewind-current-segment (dstate segment)
 496   (declare (type disassem-state dstate)
 497            (type segment segment))
 498   (setf (dstate-segment dstate) segment)
 499   (setf (dstate-cur-offs-hooks dstate)
 500         (stable-sort (nreverse (copy-list (seg-hooks segment)))
 501                      (lambda (oh1 oh2)
 502                        (or (< (offs-hook-offset oh1) (offs-hook-offset oh2))
 503                            (and (= (offs-hook-offset oh1)
 504                                    (offs-hook-offset oh2))
 505                                 (offs-hook-before-address oh1)
 506                                 (not (offs-hook-before-address oh2)))))))
 507   (setf (dstate-cur-offs dstate) 0)
 508   (setf (dstate-cur-labels dstate) (dstate-labels dstate)))
 509
 510 (defun call-offs-hooks (before-address stream dstate)
 511   (declare (type (or null stream) stream)
 512            (type disassem-state dstate))
 513   (let ((cur-offs (dstate-cur-offs dstate)))
 514     (setf (dstate-next-offs dstate) cur-offs)
 515     (loop
 516       (let ((next-hook (car (dstate-cur-offs-hooks dstate))))
 517         (when (null next-hook)
 518           (return))
 519         (let ((hook-offs (offs-hook-offset next-hook)))
 520           (when (or (> hook-offs cur-offs)
 521                     (and (= hook-offs cur-offs)
 522                          before-address
 523                          (not (offs-hook-before-address next-hook))))
 524             (return))
 525           (unless (< hook-offs cur-offs)
 526             (funcall (offs-hook-fun next-hook) stream dstate))
 527           (pop (dstate-cur-offs-hooks dstate))
 528           (unless (= (dstate-next-offs dstate) cur-offs)
 529             (return)))))))
 530
 531 (defun call-fun-hooks (chunk stream dstate)
 532   (let ((hooks (dstate-fun-hooks dstate))
 533         (cur-offs (dstate-cur-offs dstate)))
 534     (setf (dstate-next-offs dstate) cur-offs)
 535     (dolist (hook hooks nil)
 536       (let ((prefix-p (funcall hook chunk stream dstate)))
 537         (unless (= (dstate-next-offs dstate) cur-offs)
 538           (return prefix-p))))))
 539
 540 (defun handle-bogus-instruction (stream dstate)
 541   (let ((alignment (dstate-alignment dstate)))
 542     (unless (null stream)
 543       (multiple-value-bind (words bytes)
 544           (truncate alignment sb!vm:n-word-bytes)
 545         (when (> words 0)
 546           (print-words words stream dstate))
 547         (when (> bytes 0)
 548           (print-bytes bytes stream dstate))))
 549     (incf (dstate-next-offs dstate) alignment)))
 550
 551 ;;; Iterate through the instructions in SEGMENT, calling FUNCTION for
 552 ;;; each instruction, with arguments of CHUNK, STREAM, and DSTATE.
 553 (defun map-segment-instructions (function segment dstate &optional stream)
 554   (declare (type function function)
 555            (type segment segment)
 556            (type disassem-state dstate)
 557            (type (or null stream) stream))
 558
 559   (let ((ispace (get-inst-space))
 560         (prefix-p nil)) ; just processed a prefix inst
 561
 562     (rewind-current-segment dstate segment)
 563
 564     (loop
 565       (when (>= (dstate-cur-offs dstate)
 566                 (seg-length (dstate-segment dstate)))
 567         ;; done!
 568         (return))
 569
 570       (setf (dstate-next-offs dstate) (dstate-cur-offs dstate))
 571
 572       (call-offs-hooks t stream dstate)
 573       (unless (or prefix-p (null stream))
 574         (print-current-address stream dstate))
 575       (call-offs-hooks nil stream dstate)
 576
 577       (unless (> (dstate-next-offs dstate) (dstate-cur-offs dstate))
 578         (sb!sys:without-gcing
 579          (setf (dstate-segment-sap dstate) (funcall (seg-sap-maker segment)))
 580
 581          (let ((chunk
 582                 (sap-ref-dchunk (dstate-segment-sap dstate)
 583                                 (dstate-cur-offs dstate)
 584                                 (dstate-byte-order dstate))))
 585            (let ((fun-prefix-p (call-fun-hooks chunk stream dstate)))
 586              (if (> (dstate-next-offs dstate) (dstate-cur-offs dstate))
 587                  (setf prefix-p fun-prefix-p)
 588                  (let ((inst (find-inst chunk ispace)))
 589                    (cond ((null inst)
 590                           (handle-bogus-instruction stream dstate))
 591                          (t
 592                           (setf (dstate-next-offs dstate)
 593                                 (+ (dstate-cur-offs dstate)
 594                                    (inst-length inst)))
 595
 596                           (let ((prefilter (inst-prefilter inst))
 597                                 (control (inst-control inst)))
 598                             (when prefilter
 599                               (funcall prefilter chunk dstate))
 600
 601                             (funcall function chunk inst)
 602
 603                             (setf prefix-p (null (inst-printer inst)))
 604
 605                             (when control
 606                               (funcall control chunk inst stream dstate))))))
 607                  )))))
 608
 609       (setf (dstate-cur-offs dstate) (dstate-next-offs dstate))
 610
 611       (unless (null stream)
 612         (unless prefix-p
 613           (print-notes-and-newline stream dstate))
 614         (setf (dstate-output-state dstate) nil)))))
 615 \f
 616 ;;; Make an initial non-printing disassembly pass through DSTATE,
 617 ;;; noting any addresses that are referenced by instructions in this
 618 ;;; segment.
 619 (defun add-segment-labels (segment dstate)
 620   ;; add labels at the beginning with a label-number of nil; we'll notice
 621   ;; later and fill them in (and sort them)
 622   (declare (type disassem-state dstate))
 623   (let ((labels (dstate-labels dstate)))
 624     (map-segment-instructions
 625      (lambda (chunk inst)
 626        (declare (type dchunk chunk) (type instruction inst))
 627        (let ((labeller (inst-labeller inst)))
 628          (when labeller
 629            (setf labels (funcall labeller chunk labels dstate)))))
 630      segment
 631      dstate)
 632     (setf (dstate-labels dstate) labels)
 633     ;; erase any notes that got there by accident
 634     (setf (dstate-notes dstate) nil)))
 635
 636 ;;; If any labels in DSTATE have been added since the last call to
 637 ;;; this function, give them label-numbers, enter them in the
 638 ;;; hash-table, and make sure the label list is in sorted order.
 639 (defun number-labels (dstate)
 640   (let ((labels (dstate-labels dstate)))
 641     (when (and labels (null (cdar labels)))
 642       ;; at least one label left un-numbered
 643       (setf labels (sort labels #'< :key #'car))
 644       (let ((max -1)
 645             (label-hash (dstate-label-hash dstate)))
 646         (dolist (label labels)
 647           (when (not (null (cdr label)))
 648             (setf max (max max (cdr label)))))
 649         (dolist (label labels)
 650           (when (null (cdr label))
 651             (incf max)
 652             (setf (cdr label) max)
 653             (setf (gethash (car label) label-hash)
 654                   (format nil "L~W" max)))))
 655       (setf (dstate-labels dstate) labels))))
 656 \f
 657 ;;; Get the instruction-space, creating it if necessary.
 658 (defun get-inst-space ()
 659   (let ((ispace *disassem-inst-space*))
 660     (when (null ispace)
 661       (let ((insts nil))
 662         (maphash (lambda (name inst-flavs)
 663                    (declare (ignore name))
 664                    (dolist (flav inst-flavs)
 665                      (push flav insts)))
 666                  *disassem-insts*)
 667         (setf ispace (build-inst-space insts)))
 668       (setf *disassem-inst-space* ispace))
 669     ispace))
 670 \f
 671 ;;;; Add global hooks.
 672
 673 (defun add-offs-hook (segment addr hook)
 674   (let ((entry (cons addr hook)))
 675     (if (null (seg-hooks segment))
 676         (setf (seg-hooks segment) (list entry))
 677         (push entry (cdr (last (seg-hooks segment)))))))
 678
 679 (defun add-offs-note-hook (segment addr note)
 680   (add-offs-hook segment
 681                  addr
 682                  (lambda (stream dstate)
 683                    (declare (type (or null stream) stream)
 684                             (type disassem-state dstate))
 685                    (when stream
 686                      (note note dstate)))))
 687
 688 (defun add-offs-comment-hook (segment addr comment)
 689   (add-offs-hook segment
 690                  addr
 691                  (lambda (stream dstate)
 692                    (declare (type (or null stream) stream)
 693                             (ignore dstate))
 694                    (when stream
 695                      (write-string ";;; " stream)
 696                      (etypecase comment
 697                        (string
 698                         (write-string comment stream))
 699                        (function
 700                         (funcall comment stream)))
 701                      (terpri stream)))))
 702
 703 (defun add-fun-hook (dstate function)
 704   (push function (dstate-fun-hooks dstate)))
 705 \f
 706 (defun set-location-printing-range (dstate from length)
 707   (setf (dstate-addr-print-len dstate)
 708         ;; 4 bits per hex digit
 709         (ceiling (integer-length (logxor from (+ from length))) 4)))
 710
 711 ;;; Print the current address in DSTATE to STREAM, plus any labels that
 712 ;;; correspond to it, and leave the cursor in the instruction column.
 713 (defun print-current-address (stream dstate)
 714   (declare (type stream stream)
 715            (type disassem-state dstate))
 716   (let* ((location
 717           (+ (seg-virtual-location (dstate-segment dstate))
 718              (dstate-cur-offs dstate)))
 719          (location-column-width *disassem-location-column-width*)
 720          (plen (dstate-addr-print-len dstate)))
 721
 722     (when (null plen)
 723       (setf plen location-column-width)
 724       (let ((seg (dstate-segment dstate)))
 725         (set-location-printing-range dstate
 726                                      (seg-virtual-location seg)
 727                                      (seg-length seg))))
 728     (when (eq (dstate-output-state dstate) :beginning)
 729       (setf plen location-column-width))
 730
 731     (fresh-line stream)
 732
 733     (setf location-column-width (+ 2 location-column-width))
 734     (princ "; " stream)
 735
 736     ;; print the location
 737     ;; [this is equivalent to (format stream "~V,'0x:" plen printed-value), but
 738     ;;  usually avoids any consing]
 739     (tab0 (- location-column-width plen) stream)
 740     (let* ((printed-bits (* 4 plen))
 741            (printed-value (ldb (byte printed-bits 0) location))
 742            (leading-zeros
 743             (truncate (- printed-bits (integer-length printed-value)) 4)))
 744       (dotimes (i leading-zeros)
 745         (write-char #\0 stream))
 746       (unless (zerop printed-value)
 747         (write printed-value :stream stream :base 16 :radix nil))
 748       (write-char #\: stream))
 749
 750     ;; print any labels
 751     (loop
 752       (let* ((next-label (car (dstate-cur-labels dstate)))
 753              (label-location (car next-label)))
 754         (when (or (null label-location) (> label-location location))
 755           (return))
 756         (unless (< label-location location)
 757           (format stream " L~W:" (cdr next-label)))
 758         (pop (dstate-cur-labels dstate))))
 759
 760     ;; move to the instruction column
 761     (tab0 (+ location-column-width 1 label-column-width) stream)
 762     ))
 763 \f
 764 (eval-when (:compile-toplevel :execute)
 765   (sb!xc:defmacro with-print-restrictions (&rest body)
 766     `(let ((*print-pretty* t)
 767            (*print-lines* 2)
 768            (*print-length* 4)
 769            (*print-level* 3))
 770        ,@body)))
 771
 772 ;;; Print a newline to STREAM, inserting any pending notes in DSTATE
 773 ;;; as end-of-line comments. If there is more than one note, a
 774 ;;; separate line will be used for each one.
 775 (defun print-notes-and-newline (stream dstate)
 776   (declare (type stream stream)
 777            (type disassem-state dstate))
 778   (with-print-restrictions
 779     (dolist (note (dstate-notes dstate))
 780       (format stream "~Vt " *disassem-note-column*)
 781       (pprint-logical-block (stream nil :per-line-prefix "; ")
 782       (etypecase note
 783         (string
 784          (write-string note stream))
 785         (function
 786          (funcall note stream))))
 787       (terpri stream))
 788     (fresh-line stream)
 789     (setf (dstate-notes dstate) nil)))
 790
 791 ;;; Disassemble NUM bytes to STREAM as simple `BYTE' instructions.
 792 (defun print-bytes (num stream dstate)
 793   (declare (type offset num)
 794            (type stream stream)
 795            (type disassem-state dstate))
 796   (format stream "~A~Vt" 'BYTE (dstate-argument-column dstate))
 797   (let ((sap (dstate-segment-sap dstate))
 798         (start-offs (dstate-cur-offs dstate)))
 799     (dotimes (offs num)
 800       (unless (zerop offs)
 801         (write-string ", " stream))
 802       (format stream "#X~2,'0x" (sb!sys:sap-ref-8 sap (+ offs start-offs))))))
 803
 804 ;;; Disassemble NUM machine-words to STREAM as simple `WORD' instructions.
 805 (defun print-words (num stream dstate)
 806   (declare (type offset num)
 807            (type stream stream)
 808            (type disassem-state dstate))
 809   (format stream "~A~Vt" 'WORD (dstate-argument-column dstate))
 810   (let ((sap (dstate-segment-sap dstate))
 811         (start-offs (dstate-cur-offs dstate))
 812         (byte-order (dstate-byte-order dstate)))
 813     (dotimes (word-offs num)
 814       (unless (zerop word-offs)
 815         (write-string ", " stream))
 816       (let ((word 0) (bit-shift 0))
 817         (dotimes (byte-offs sb!vm:n-word-bytes)
 818           (let ((byte
 819                  (sb!sys:sap-ref-8
 820                         sap
 821                         (+ start-offs
 822                            (* word-offs sb!vm:n-word-bytes)
 823                            byte-offs))))
 824             (setf word
 825                   (if (eq byte-order :big-endian)
 826                       (+ (ash word sb!vm:n-byte-bits) byte)
 827                       (+ word (ash byte bit-shift))))
 828             (incf bit-shift sb!vm:n-byte-bits)))
 829         (format stream "#X~V,'0X" (ash sb!vm:n-word-bits -2) word)))))
 830 \f
 831 (defvar *default-dstate-hooks* (list #'lra-hook))
 832
 833 ;;; Make a disassembler-state object.
 834 (defun make-dstate (&optional (fun-hooks *default-dstate-hooks*))
 835   (let ((sap
 836          (sb!sys:vector-sap (coerce #() '(vector (unsigned-byte 8)))))
 837         (alignment *disassem-inst-alignment-bytes*)
 838         (arg-column
 839          (+ (or *disassem-opcode-column-width* 0)
 840             *disassem-location-column-width*
 841             1
 842             label-column-width)))
 843
 844     (when (> alignment 1)
 845       (push #'alignment-hook fun-hooks))
 846
 847     (%make-dstate :segment-sap sap
 848                   :fun-hooks fun-hooks
 849                   :argument-column arg-column
 850                   :alignment alignment
 851                   :byte-order sb!c:*backend-byte-order*)))
 852
 853 (defun add-fun-header-hooks (segment)
 854   (declare (type segment segment))
 855   (do ((fun (sb!kernel:code-header-ref (seg-code segment)
 856                                        sb!vm:code-entry-points-slot)
 857             (fun-next fun))
 858        (length (seg-length segment)))
 859       ((null fun))
 860     (let ((offset (code-offs-to-segment-offs (fun-offset fun) segment)))
 861       (when (<= 0 offset length)
 862         (push (make-offs-hook :offset offset :fun #'fun-header-hook)
 863               (seg-hooks segment))))))
 864 \f
 865 ;;; A SAP-MAKER is a no-argument function that returns a SAP.
 866
 867 #!-sb-fluid (declaim (inline sap-maker))
 868
 869 (defun sap-maker (function input offset)
 870   (declare (optimize (speed 3))
 871            (type (function (t) sb!sys:system-area-pointer) function)
 872            (type offset offset))
 873   (let ((old-sap (sb!sys:sap+ (funcall function input) offset)))
 874     (declare (type sb!sys:system-area-pointer old-sap))
 875     (lambda ()
 876       (let ((new-addr
 877              (+ (sb!sys:sap-int (funcall function input)) offset)))
 878         ;; Saving the sap like this avoids consing except when the sap
 879         ;; changes (because the sap-int, arith, etc., get inlined).
 880         (declare (type address new-addr))
 881         (if (= (sb!sys:sap-int old-sap) new-addr)
 882             old-sap
 883             (setf old-sap (sb!sys:int-sap new-addr)))))))
 884
 885 (defun vector-sap-maker (vector offset)
 886   (declare (optimize (speed 3))
 887            (type offset offset))
 888   (sap-maker #'sb!sys:vector-sap vector offset))
 889
 890 (defun code-sap-maker (code offset)
 891   (declare (optimize (speed 3))
 892            (type sb!kernel:code-component code)
 893            (type offset offset))
 894   (sap-maker #'sb!kernel:code-instructions code offset))
 895
 896 (defun memory-sap-maker (address)
 897   (declare (optimize (speed 3))
 898            (type address address))
 899   (let ((sap (sb!sys:int-sap address)))
 900     (lambda () sap)))
 901 \f
 902 ;;; Return a memory segment located at the system-area-pointer returned by
 903 ;;; SAP-MAKER and LENGTH bytes long in the disassem-state object DSTATE.
 904 ;;;
 905 ;;; &KEY arguments include :VIRTUAL-LOCATION (by default the same as
 906 ;;; the address), :DEBUG-FUN, :SOURCE-FORM-CACHE (a
 907 ;;; SOURCE-FORM-CACHE object), and :HOOKS (a list of OFFS-HOOK
 908 ;;; objects).
 909 (defun make-segment (sap-maker length
 910                      &key
 911                      code virtual-location
 912                      debug-fun source-form-cache
 913                      hooks)
 914   (declare (type (function () sb!sys:system-area-pointer) sap-maker)
 915            (type length length)
 916            (type (or null address) virtual-location)
 917            (type (or null sb!di:debug-fun) debug-fun)
 918            (type (or null source-form-cache) source-form-cache))
 919   (let* ((segment
 920           (%make-segment
 921            :sap-maker sap-maker
 922            :length length
 923            :virtual-location (or virtual-location
 924                                  (sb!sys:sap-int (funcall sap-maker)))
 925            :hooks hooks
 926            :code code)))
 927     (add-debugging-hooks segment debug-fun source-form-cache)
 928     (add-fun-header-hooks segment)
 929     segment))
 930
 931 (defun make-vector-segment (vector offset &rest args)
 932   (declare (type vector vector)
 933            (type offset offset)
 934            (inline make-segment))
 935   (apply #'make-segment (vector-sap-maker vector offset) args))
 936
 937 (defun make-code-segment (code offset length &rest args)
 938   (declare (type sb!kernel:code-component code)
 939            (type offset offset)
 940            (inline make-segment))
 941   (apply #'make-segment (code-sap-maker code offset) length :code code args))
 942
 943 (defun make-memory-segment (address &rest args)
 944   (declare (type address address)
 945            (inline make-segment))
 946   (apply #'make-segment (memory-sap-maker address) args))
 947 \f
 948 ;;; just for fun
 949 (defun print-fun-headers (function)
 950   (declare (type compiled-function function))
 951   (let* ((self (fun-self function))
 952          (code (sb!kernel:fun-code-header self)))
 953     (format t "Code-header ~S: size: ~S, trace-table-offset: ~S~%"
 954             code
 955             (sb!kernel:code-header-ref code
 956                                        sb!vm:code-code-size-slot)
 957             (sb!kernel:code-header-ref code
 958                                        sb!vm:code-trace-table-offset-slot))
 959     (do ((fun (sb!kernel:code-header-ref code sb!vm:code-entry-points-slot)
 960               (fun-next fun)))
 961         ((null fun))
 962       (let ((fun-offset (sb!kernel:get-closure-length fun)))
 963         ;; There is function header fun-offset words from the
 964         ;; code header.
 965         (format t "Fun-header ~S at offset ~W (words): ~S~A => ~S~%"
 966                 fun
 967                 fun-offset
 968                 (sb!kernel:code-header-ref
 969                  code (+ fun-offset sb!vm:simple-fun-name-slot))
 970                 (sb!kernel:code-header-ref
 971                  code (+ fun-offset sb!vm:simple-fun-arglist-slot))
 972                 (sb!kernel:code-header-ref
 973                  code (+ fun-offset sb!vm:simple-fun-type-slot)))))))
 974 \f
 975 ;;; getting at the source code...
 976
 977 (defstruct (source-form-cache (:conc-name sfcache-)
 978                               (:copier nil))
 979   (debug-source nil :type (or null sb!di:debug-source))
 980   (toplevel-form-index -1 :type fixnum)
 981   (toplevel-form nil :type list)
 982   (form-number-mapping-table nil :type (or null (vector list)))
 983   (last-location-retrieved nil :type (or null sb!di:code-location))
 984   (last-form-retrieved -1 :type fixnum))
 985
 986 (defun get-toplevel-form (debug-source tlf-index)
 987   (let ((name (sb!di:debug-source-name debug-source)))
 988     (ecase (sb!di:debug-source-from debug-source)
 989       (:file
 990        (cond ((not (probe-file name))
 991               (warn "The source file ~S no longer seems to exist." name)
 992               nil)
 993              (t
 994               (let ((start-positions
 995                      (sb!di:debug-source-start-positions debug-source)))
 996                 (cond ((null start-positions)
 997                        (warn "There is no start positions map.")
 998                        nil)
 999                       (t
1000                        (let* ((local-tlf-index
1001                                (- tlf-index
1002                                   (sb!di:debug-source-root-number
1003                                    debug-source)))
1004                               (char-offset
1005                                (aref start-positions local-tlf-index)))
1006                          (with-open-file (f name)
1007                            (cond ((= (sb!di:debug-source-created debug-source)
1008                                      (file-write-date name))
1009                                   (file-position f char-offset))
1010                                  (t
1011                                   (warn "Source file ~S has been modified; ~@
1012                                          using form offset instead of ~
1013                                          file index."
1014                                         name)
1015                                   (let ((*read-suppress* t))
1016                                     (dotimes (i local-tlf-index) (read f)))))
1017                            (let ((*readtable* (copy-readtable)))
1018                              (set-dispatch-macro-character
1019                               #\# #\.
1020                               (lambda (stream sub-char &rest rest)
1021                                 (declare (ignore rest sub-char))
1022                                 (let ((token (read stream t nil t)))
1023                                   (format nil "#.~S" token))))
1024                              (read f))
1025                            ))))))))
1026       (:lisp
1027        (aref name tlf-index)))))
1028
1029 (defun cache-valid (loc cache)
1030   (and cache
1031        (and (eq (sb!di:code-location-debug-source loc)
1032                 (sfcache-debug-source cache))
1033             (eq (sb!di:code-location-toplevel-form-offset loc)
1034                 (sfcache-toplevel-form-index cache)))))
1035
1036 (defun get-source-form (loc context &optional cache)
1037   (let* ((cache-valid (cache-valid loc cache))
1038          (tlf-index (sb!di:code-location-toplevel-form-offset loc))
1039          (form-number (sb!di:code-location-form-number loc))
1040          (toplevel-form
1041           (if cache-valid
1042               (sfcache-toplevel-form cache)
1043               (get-toplevel-form (sb!di:code-location-debug-source loc)
1044                                   tlf-index)))
1045          (mapping-table
1046           (if cache-valid
1047               (sfcache-form-number-mapping-table cache)
1048               (sb!di:form-number-translations toplevel-form tlf-index))))
1049     (when (and (not cache-valid) cache)
1050       (setf (sfcache-debug-source cache) (sb!di:code-location-debug-source loc)
1051             (sfcache-toplevel-form-index cache) tlf-index
1052             (sfcache-toplevel-form cache) toplevel-form
1053             (sfcache-form-number-mapping-table cache) mapping-table))
1054     (cond ((null toplevel-form)
1055            nil)
1056           ((> form-number (length mapping-table))
1057            (warn "bogus form-number in form!  The source file has probably ~@
1058                   been changed too much to cope with.")
1059            (when cache
1060              ;; Disable future warnings.
1061              (setf (sfcache-toplevel-form cache) nil))
1062            nil)
1063           (t
1064            (when cache
1065              (setf (sfcache-last-location-retrieved cache) loc)
1066              (setf (sfcache-last-form-retrieved cache) form-number))
1067            (sb!di:source-path-context toplevel-form
1068                                       (aref mapping-table form-number)
1069                                       context)))))
1070
1071 (defun get-different-source-form (loc context &optional cache)
1072   (if (and (cache-valid loc cache)
1073            (or (= (sb!di:code-location-form-number loc)
1074                   (sfcache-last-form-retrieved cache))
1075                (and (sfcache-last-location-retrieved cache)
1076                     (sb!di:code-location=
1077                      loc
1078                      (sfcache-last-location-retrieved cache)))))
1079       (values nil nil)
1080       (values (get-source-form loc context cache) t)))
1081 \f
1082 ;;;; stuff to use debugging info to augment the disassembly
1083
1084 (defun code-fun-map (code)
1085   (declare (type sb!kernel:code-component code))
1086   (sb!c::compiled-debug-info-fun-map (sb!kernel:%code-debug-info code)))
1087
1088 (defstruct (location-group (:copier nil))
1089   (locations #() :type (vector (or list fixnum))))
1090
1091 (defstruct (storage-info (:copier nil))
1092   (groups nil :type list)               ; alist of (name . location-group)
1093   (debug-vars #() :type vector))
1094
1095 ;;; Return the vector of DEBUG-VARs currently associated with DSTATE.
1096 (defun dstate-debug-vars (dstate)
1097   (declare (type disassem-state dstate))
1098   (storage-info-debug-vars (seg-storage-info (dstate-segment dstate))))
1099
1100 ;;; Given the OFFSET of a location within the location-group called
1101 ;;; LG-NAME, see whether there's a current mapping to a source
1102 ;;; variable in DSTATE, and if so, return the offset of that variable
1103 ;;; in the current debug-var vector.
1104 (defun find-valid-storage-location (offset lg-name dstate)
1105   (declare (type offset offset)
1106            (type symbol lg-name)
1107            (type disassem-state dstate))
1108   (let* ((storage-info
1109           (seg-storage-info (dstate-segment dstate)))
1110          (location-group
1111           (and storage-info
1112                (cdr (assoc lg-name (storage-info-groups storage-info)))))
1113          (currently-valid
1114           (dstate-current-valid-locations dstate)))
1115     (and location-group
1116          (not (null currently-valid))
1117          (let ((locations (location-group-locations location-group)))
1118            (and (< offset (length locations))
1119                 (let ((used-by (aref locations offset)))
1120                   (and used-by
1121                        (let ((debug-var-num
1122                               (typecase used-by
1123                                 (fixnum
1124                                  (and (not
1125                                        (zerop (bit currently-valid used-by)))
1126                                       used-by))
1127                                 (list
1128                                  (some (lambda (num)
1129                                          (and (not
1130                                                (zerop
1131                                                 (bit currently-valid num)))
1132                                               num))
1133                                        used-by)))))
1134                          (and debug-var-num
1135                               (progn
1136                                 ;; Found a valid storage reference!
1137                                 ;; can't use it again until it's revalidated...
1138                                 (setf (bit (dstate-current-valid-locations
1139                                             dstate)
1140                                            debug-var-num)
1141                                       0)
1142                                 debug-var-num))
1143                          ))))))))
1144
1145 ;;; Return a new vector which has the same contents as the old one
1146 ;;; VEC, plus new cells (for a total size of NEW-LEN). The additional
1147 ;;; elements are initialized to INITIAL-ELEMENT.
1148 (defun grow-vector (vec new-len &optional initial-element)
1149   (declare (type vector vec)
1150            (type fixnum new-len))
1151   (let ((new
1152          (make-sequence `(vector ,(array-element-type vec) ,new-len)
1153                         new-len
1154                         :initial-element initial-element)))
1155     (dotimes (i (length vec))
1156       (setf (aref new i) (aref vec i)))
1157     new))
1158
1159 ;;; Return a STORAGE-INFO struction describing the object-to-source
1160 ;;; variable mappings from DEBUG-FUN.
1161 (defun storage-info-for-debug-fun (debug-fun)
1162   (declare (type sb!di:debug-fun debug-fun))
1163   (let ((sc-vec sb!c::*backend-sc-numbers*)
1164         (groups nil)
1165         (debug-vars (sb!di::debug-fun-debug-vars
1166                      debug-fun)))
1167     (and debug-vars
1168          (dotimes (debug-var-offset
1169                    (length debug-vars)
1170                    (make-storage-info :groups groups
1171                                       :debug-vars debug-vars))
1172            (let ((debug-var (aref debug-vars debug-var-offset)))
1173              #+nil
1174              (format t ";;; At offset ~W: ~S~%" debug-var-offset debug-var)
1175              (let* ((sc-offset
1176                      (sb!di::compiled-debug-var-sc-offset debug-var))
1177                     (sb-name
1178                      (sb!c:sb-name
1179                       (sb!c:sc-sb (aref sc-vec
1180                                         (sb!c:sc-offset-scn sc-offset))))))
1181                #+nil
1182                (format t ";;; SET: ~S[~W]~%"
1183                        sb-name (sb!c:sc-offset-offset sc-offset))
1184                (unless (null sb-name)
1185                  (let ((group (cdr (assoc sb-name groups))))
1186                    (when (null group)
1187                      (setf group (make-location-group))
1188                      (push `(,sb-name . ,group) groups))
1189                    (let* ((locations (location-group-locations group))
1190                           (length (length locations))
1191                           (offset (sb!c:sc-offset-offset sc-offset)))
1192                      (when (>= offset length)
1193                        (setf locations
1194                              (grow-vector locations
1195                                           (max (* 2 length)
1196                                                (1+ offset))
1197                                           nil)
1198                              (location-group-locations group)
1199                              locations))
1200                      (let ((already-there (aref locations offset)))
1201                        (cond ((null already-there)
1202                               (setf (aref locations offset) debug-var-offset))
1203                              ((eql already-there debug-var-offset))
1204                              (t
1205                               (if (listp already-there)
1206                                   (pushnew debug-var-offset
1207                                            (aref locations offset))
1208                                   (setf (aref locations offset)
1209                                         (list debug-var-offset
1210                                               already-there)))))
1211                        )))))))
1212          )))
1213
1214 (defun source-available-p (debug-fun)
1215   (handler-case
1216       (sb!di:do-debug-fun-blocks (block debug-fun)
1217         (declare (ignore block))
1218         (return t))
1219     (sb!di:no-debug-blocks () nil)))
1220
1221 (defun print-block-boundary (stream dstate)
1222   (let ((os (dstate-output-state dstate)))
1223     (when (not (eq os :beginning))
1224       (when (not (eq os :block-boundary))
1225         (terpri stream))
1226       (setf (dstate-output-state dstate)
1227             :block-boundary))))
1228
1229 ;;; Add hooks to track to track the source code in SEGMENT during
1230 ;;; disassembly. SFCACHE can be either NIL or it can be a
1231 ;;; SOURCE-FORM-CACHE structure, in which case it is used to cache
1232 ;;; forms from files.
1233 (defun add-source-tracking-hooks (segment debug-fun &optional sfcache)
1234   (declare (type segment segment)
1235            (type (or null sb!di:debug-fun) debug-fun)
1236            (type (or null source-form-cache) sfcache))
1237   (let ((last-block-pc -1))
1238     (flet ((add-hook (pc fun &optional before-address)
1239              (push (make-offs-hook
1240                     :offset pc ;; ### FIX to account for non-zero offs in code
1241                     :fun fun
1242                     :before-address before-address)
1243                    (seg-hooks segment))))
1244       (handler-case
1245           (sb!di:do-debug-fun-blocks (block debug-fun)
1246             (let ((first-location-in-block-p t))
1247               (sb!di:do-debug-block-locations (loc block)
1248                 (let ((pc (sb!di::compiled-code-location-pc loc)))
1249
1250                   ;; Put blank lines in at block boundaries
1251                   (when (and first-location-in-block-p
1252                              (/= pc last-block-pc))
1253                     (setf first-location-in-block-p nil)
1254                     (add-hook pc
1255                               (lambda (stream dstate)
1256                                 (print-block-boundary stream dstate))
1257                               t)
1258                     (setf last-block-pc pc))
1259
1260                   ;; Print out corresponding source; this information is not
1261                   ;; all that accurate, but it's better than nothing
1262                   (unless (zerop (sb!di:code-location-form-number loc))
1263                     (multiple-value-bind (form new)
1264                         (get-different-source-form loc 0 sfcache)
1265                       (when new
1266                          (let ((at-block-begin (= pc last-block-pc)))
1267                            (add-hook
1268                             pc
1269                             (lambda (stream dstate)
1270                               (declare (ignore dstate))
1271                               (when stream
1272                                 (unless at-block-begin
1273                                   (terpri stream))
1274                                 (format stream ";;; [~W] "
1275                                         (sb!di:code-location-form-number
1276                                          loc))
1277                                 (prin1-short form stream)
1278                                 (terpri stream)
1279                                 (terpri stream)))
1280                             t)))))
1281
1282                   ;; Keep track of variable live-ness as best we can.
1283                   (let ((live-set
1284                          (copy-seq (sb!di::compiled-code-location-live-set
1285                                     loc))))
1286                     (add-hook
1287                      pc
1288                      (lambda (stream dstate)
1289                        (declare (ignore stream))
1290                        (setf (dstate-current-valid-locations dstate)
1291                              live-set)
1292                        #+nil
1293                        (note (lambda (stream)
1294                                (let ((*print-length* nil))
1295                                  (format stream "live set: ~S"
1296                                          live-set)))
1297                              dstate))))
1298                   ))))
1299         (sb!di:no-debug-blocks () nil)))))
1300
1301 (defun add-debugging-hooks (segment debug-fun &optional sfcache)
1302   (when debug-fun
1303     (setf (seg-storage-info segment)
1304           (storage-info-for-debug-fun debug-fun))
1305     (add-source-tracking-hooks segment debug-fun sfcache)
1306     (let ((kind (sb!di:debug-fun-kind debug-fun)))
1307       (flet ((add-new-hook (n)
1308                (push (make-offs-hook
1309                       :offset 0
1310                       :fun (lambda (stream dstate)
1311                              (declare (ignore stream))
1312                              (note n dstate)))
1313                      (seg-hooks segment))))
1314         (case kind
1315           (:external)
1316           ((nil)
1317            (add-new-hook "no-arg-parsing entry point"))
1318           (t
1319            (add-new-hook (lambda (stream)
1320                            (format stream "~S entry point" kind)))))))))
1321 \f
1322 ;;; Return a list of the segments of memory containing machine code
1323 ;;; instructions for FUNCTION.
1324 (defun get-fun-segments (function)
1325   (declare (type compiled-function function))
1326   (let* ((code (fun-code function))
1327          (fun-map (code-fun-map code))
1328          (fname (sb!kernel:%simple-fun-name function))
1329          (sfcache (make-source-form-cache)))
1330     (let ((first-block-seen-p nil)
1331           (nil-block-seen-p nil)
1332           (last-offset 0)
1333           (last-debug-fun nil)
1334           (segments nil))
1335       (flet ((add-seg (offs len df)
1336                (when (> len 0)
1337                  (push (make-code-segment code offs len
1338                                           :debug-fun df
1339                                           :source-form-cache sfcache)
1340                        segments))))
1341         (dotimes (fmap-index (length fun-map))
1342           (let ((fmap-entry (aref fun-map fmap-index)))
1343             (etypecase fmap-entry
1344               (integer
1345                (when first-block-seen-p
1346                  (add-seg last-offset
1347                           (- fmap-entry last-offset)
1348                           last-debug-fun)
1349                  (setf last-debug-fun nil))
1350                (setf last-offset fmap-entry))
1351               (sb!c::compiled-debug-fun
1352                (let ((name (sb!c::compiled-debug-fun-name fmap-entry))
1353                      (kind (sb!c::compiled-debug-fun-kind fmap-entry)))
1354                  #+nil
1355                  (format t ";;; SAW ~S ~S ~S,~S ~W,~W~%"
1356                          name kind first-block-seen-p nil-block-seen-p
1357                          last-offset
1358                          (sb!c::compiled-debug-fun-start-pc fmap-entry))
1359                  (cond (#+nil (eq last-offset fun-offset)
1360                               (and (equal name fname) (not first-block-seen-p))
1361                               (setf first-block-seen-p t))
1362                        ((eq kind :external)
1363                         (when first-block-seen-p
1364                           (return)))
1365                        ((eq kind nil)
1366                         (when nil-block-seen-p
1367                           (return))
1368                         (when first-block-seen-p
1369                           (setf nil-block-seen-p t))))
1370                  (setf last-debug-fun
1371                        (sb!di::make-compiled-debug-fun fmap-entry code)))))))
1372         (let ((max-offset (code-inst-area-length code)))
1373           (when (and first-block-seen-p last-debug-fun)
1374             (add-seg last-offset
1375                      (- max-offset last-offset)
1376                      last-debug-fun))
1377           (if (null segments)
1378               (let ((offs (fun-insts-offset function)))
1379                 (list
1380                  (make-code-segment code offs (- max-offset offs))))
1381               (nreverse segments)))))))
1382
1383 ;;; Return a list of the segments of memory containing machine code
1384 ;;; instructions for the code-component CODE. If START-OFFSET and/or
1385 ;;; LENGTH is supplied, only that part of the code-segment is used
1386 ;;; (but these are constrained to lie within the code-segment).
1387 (defun get-code-segments (code
1388                           &optional
1389                           (start-offset 0)
1390                           (length (code-inst-area-length code)))
1391   (declare (type sb!kernel:code-component code)
1392            (type offset start-offset)
1393            (type length length))
1394   (let ((segments nil))
1395     (when code
1396       (let ((fun-map (code-fun-map code))
1397             (sfcache (make-source-form-cache)))
1398         (let ((last-offset 0)
1399               (last-debug-fun nil))
1400           (flet ((add-seg (offs len df)
1401                    (let* ((restricted-offs
1402                            (min (max start-offset offs)
1403                                 (+ start-offset length)))
1404                           (restricted-len
1405                            (- (min (max start-offset (+ offs len))
1406                                    (+ start-offset length))
1407                               restricted-offs)))
1408                      (when (> restricted-len 0)
1409                        (push (make-code-segment code
1410                                                 restricted-offs restricted-len
1411                                                 :debug-fun df
1412                                                 :source-form-cache sfcache)
1413                              segments)))))
1414             (dotimes (fun-map-index (length fun-map))
1415               (let ((fun-map-entry (aref fun-map fun-map-index)))
1416                 (etypecase fun-map-entry
1417                   (integer
1418                    (add-seg last-offset (- fun-map-entry last-offset)
1419                             last-debug-fun)
1420                    (setf last-debug-fun nil)
1421                    (setf last-offset fun-map-entry))
1422                   (sb!c::compiled-debug-fun
1423                    (setf last-debug-fun
1424                          (sb!di::make-compiled-debug-fun fun-map-entry
1425                                                          code))))))
1426             (when last-debug-fun
1427               (add-seg last-offset
1428                        (- (code-inst-area-length code) last-offset)
1429                        last-debug-fun))))))
1430     (if (null segments)
1431         (make-code-segment code start-offset length)
1432         (nreverse segments))))
1433 \f
1434 ;;; Return two values: the amount by which the last instruction in the
1435 ;;; segment goes past the end of the segment, and the offset of the
1436 ;;; end of the segment from the beginning of that instruction. If all
1437 ;;; instructions fit perfectly, return 0 and 0.
1438 (defun segment-overflow (segment dstate)
1439   (declare (type segment segment)
1440            (type disassem-state dstate))
1441   (let ((seglen (seg-length segment))
1442         (last-start 0))
1443     (map-segment-instructions (lambda (chunk inst)
1444                                 (declare (ignore chunk inst))
1445                                 (setf last-start (dstate-cur-offs dstate)))
1446                               segment
1447                               dstate)
1448     (values (- (dstate-cur-offs dstate) seglen)
1449             (- seglen last-start))))
1450
1451 ;;; Compute labels for all the memory segments in SEGLIST and adds
1452 ;;; them to DSTATE. It's important to call this function with all the
1453 ;;; segments you're interested in, so that it can find references from
1454 ;;; one to another.
1455 (defun label-segments (seglist dstate)
1456   (declare (type list seglist)
1457            (type disassem-state dstate))
1458   (dolist (seg seglist)
1459     (add-segment-labels seg dstate))
1460   ;; Now remove any labels that don't point anywhere in the segments
1461   ;; we have.
1462   (setf (dstate-labels dstate)
1463         (remove-if (lambda (lab)
1464                      (not
1465                       (some (lambda (seg)
1466                               (let ((start (seg-virtual-location seg)))
1467                                 (<= start
1468                                     (car lab)
1469                                     (+ start (seg-length seg)))))
1470                             seglist)))
1471                    (dstate-labels dstate))))
1472
1473 ;;; Disassemble the machine code instructions in SEGMENT to STREAM.
1474 (defun disassemble-segment (segment stream dstate)
1475   (declare (type segment segment)
1476            (type stream stream)
1477            (type disassem-state dstate))
1478   (let ((*print-pretty* nil)) ; otherwise the pp conses hugely
1479     (number-labels dstate)
1480     (map-segment-instructions
1481      (lambda (chunk inst)
1482        (declare (type dchunk chunk) (type instruction inst))
1483        (let ((printer (inst-printer inst)))
1484          (when printer
1485            (funcall printer chunk inst stream dstate))))
1486      segment
1487      dstate
1488      stream)))
1489
1490 ;;; Disassemble the machine code instructions in each memory segment
1491 ;;; in SEGMENTS in turn to STREAM.
1492 (defun disassemble-segments (segments stream dstate)
1493   (declare (type list segments)
1494            (type stream stream)
1495            (type disassem-state dstate))
1496   (unless (null segments)
1497     (let ((first (car segments))
1498           (last (car (last segments))))
1499       (set-location-printing-range dstate
1500                                   (seg-virtual-location first)
1501                                   (- (+ (seg-virtual-location last)
1502                                         (seg-length last))
1503                                      (seg-virtual-location first)))
1504       (setf (dstate-output-state dstate) :beginning)
1505       (dolist (seg segments)
1506         (disassemble-segment seg stream dstate)))))
1507 \f
1508 ;;;; top level functions
1509
1510 ;;; Disassemble the machine code instructions for FUNCTION.
1511 (defun disassemble-fun (fun &key
1512                             (stream *standard-output*)
1513                             (use-labels t))
1514   (declare (type compiled-function fun)
1515            (type stream stream)
1516            (type (member t nil) use-labels))
1517   (let* ((dstate (make-dstate))
1518          (segments (get-fun-segments fun)))
1519     (when use-labels
1520       (label-segments segments dstate))
1521     (disassemble-segments segments stream dstate)))
1522
1523 ;;; FIXME: We probably don't need this any more now that there are
1524 ;;; no interpreted functions, only compiled ones.
1525 (defun compile-function-lambda-expr (function)
1526   (declare (type function function))
1527   (multiple-value-bind (lambda closurep name)
1528       (function-lambda-expression function)
1529     (declare (ignore name))
1530     (when closurep
1531       (error "can't compile a lexical closure"))
1532     (compile nil lambda)))
1533
1534 (defun compiled-fun-or-lose (thing &optional (name thing))
1535   (cond ((or (symbolp thing)
1536              (and (listp thing)
1537                   (eq (car thing) 'setf)))
1538          (compiled-fun-or-lose (fdefinition thing) thing))
1539         ((functionp thing)
1540          thing)
1541         ((and (listp thing)
1542               (eq (car thing) 'lambda))
1543          (compile nil thing))
1544         (t
1545          (error "can't make a compiled function from ~S" name))))
1546
1547 (defun disassemble (object &key
1548                            (stream *standard-output*)
1549                            (use-labels t))
1550   #!+sb-doc
1551   "Disassemble the compiled code associated with OBJECT, which can be a
1552   function, a lambda expression, or a symbol with a function definition. If
1553   it is not already compiled, the compiler is called to produce something to
1554   disassemble."
1555   (declare (type (or function symbol cons) object)
1556            (type (or (member t) stream) stream)
1557            (type (member t nil) use-labels))
1558   (pprint-logical-block (*standard-output* nil :per-line-prefix "; ")
1559     (disassemble-fun (compiled-fun-or-lose object)
1560                      :stream stream
1561                      :use-labels use-labels)
1562     nil))
1563
1564 ;;; Disassembles the given area of memory starting at ADDRESS and
1565 ;;; LENGTH long. Note that if CODE-COMPONENT is NIL and this memory
1566 ;;; could move during a GC, you'd better disable it around the call to
1567 ;;; this function.
1568 (defun disassemble-memory (address
1569                            length
1570                            &key
1571                            (stream *standard-output*)
1572                            code-component
1573                            (use-labels t))
1574   (declare (type (or address sb!sys:system-area-pointer) address)
1575            (type length length)
1576            (type stream stream)
1577            (type (or null sb!kernel:code-component) code-component)
1578            (type (member t nil) use-labels))
1579   (let* ((address
1580           (if (sb!sys:system-area-pointer-p address)
1581               (sb!sys:sap-int address)
1582               address))
1583          (dstate (make-dstate))
1584          (segments
1585           (if code-component
1586               (let ((code-offs
1587                      (- address
1588                         (sb!sys:sap-int
1589                          (sb!kernel:code-instructions code-component)))))
1590                 (when (or (< code-offs 0)
1591                           (> code-offs (code-inst-area-length code-component)))
1592                   (error "address ~X not in the code component ~S"
1593                          address code-component))
1594                 (get-code-segments code-component code-offs length))
1595               (list (make-memory-segment address length)))))
1596     (when use-labels
1597       (label-segments segments dstate))
1598     (disassemble-segments segments stream dstate)))
1599
1600 ;;; Disassemble the machine code instructions associated with
1601 ;;; CODE-COMPONENT (this may include multiple entry points).
1602 (defun disassemble-code-component (code-component &key
1603                                                   (stream *standard-output*)
1604                                                   (use-labels t))
1605   (declare (type (or null sb!kernel:code-component compiled-function)
1606                  code-component)
1607            (type stream stream)
1608            (type (member t nil) use-labels))
1609   (let* ((code-component
1610           (if (functionp code-component)
1611               (fun-code code-component)
1612               code-component))
1613          (dstate (make-dstate))
1614          (segments (get-code-segments code-component)))
1615     (when use-labels
1616       (label-segments segments dstate))
1617     (disassemble-segments segments stream dstate)))
1618 \f
1619 ;;; code for making useful segments from arbitrary lists of code-blocks
1620
1621 ;;; the maximum size of an instruction. Note that this includes
1622 ;;; pseudo-instructions like error traps with their associated
1623 ;;; operands, so it should be big enough to include them, i.e. it's
1624 ;;; not just 4 on a risc machine!
1625 (defconstant max-instruction-size 16)
1626
1627 (defun add-block-segments (seg-code-block
1628                            seglist
1629                            location
1630                            connecting-vec
1631                            dstate)
1632   (declare (type list seglist)
1633            (type integer location)
1634            (type (or null (vector (unsigned-byte 8))) connecting-vec)
1635            (type disassem-state dstate))
1636   (flet ((addit (seg overflow)
1637            (let ((length (+ (seg-length seg) overflow)))
1638              (when (> length 0)
1639                (setf (seg-length seg) length)
1640                (incf location length)
1641                (push seg seglist)))))
1642     (let ((connecting-overflow 0)
1643           (amount (length seg-code-block)))
1644       (when connecting-vec
1645         ;; Tack on some of the new block to the old overflow vector.
1646         (let* ((beginning-of-block-amount
1647                 (if seg-code-block (min max-instruction-size amount) 0))
1648                (connecting-vec
1649                 (if seg-code-block
1650                     (concatenate
1651                      '(vector (unsigned-byte 8))
1652                      connecting-vec
1653                      (subseq seg-code-block 0 beginning-of-block-amount))
1654                     connecting-vec)))
1655           (when (and (< (length connecting-vec) max-instruction-size)
1656                      (not (null seg-code-block)))
1657             (return-from add-block-segments
1658               ;; We want connecting vectors to be large enough to hold
1659               ;; any instruction, and since the current seg-code-block
1660               ;; wasn't large enough to do this (and is now entirely
1661               ;; on the end of the overflow-vector), just save it for
1662               ;; next time.
1663               (values seglist location connecting-vec)))
1664           (when (> (length connecting-vec) 0)
1665             (let ((seg
1666                    (make-vector-segment connecting-vec
1667                                         0
1668                                         (- (length connecting-vec)
1669                                            beginning-of-block-amount)
1670                                         :virtual-location location)))
1671               (setf connecting-overflow (segment-overflow seg dstate))
1672               (addit seg connecting-overflow)))))
1673       (cond ((null seg-code-block)
1674              ;; nothing more to add
1675              (values seglist location nil))
1676             ((< (- amount connecting-overflow) max-instruction-size)
1677              ;; We can't create a segment with the minimum size
1678              ;; required for an instruction, so just keep on accumulating
1679              ;; in the overflow vector for the time-being.
1680              (values seglist
1681                      location
1682                      (subseq seg-code-block connecting-overflow amount)))
1683             (t
1684              ;; Put as much as we can into a new segment, and the rest
1685              ;; into the overflow-vector.
1686              (let* ((initial-length
1687                      (- amount connecting-overflow max-instruction-size))
1688                     (seg
1689                      (make-vector-segment seg-code-block
1690                                           connecting-overflow
1691                                           initial-length
1692                                           :virtual-location location))
1693                     (overflow
1694                      (segment-overflow seg dstate)))
1695                (addit seg overflow)
1696                (values seglist
1697                        location
1698                        (subseq seg-code-block
1699                                (+ connecting-overflow (seg-length seg))
1700                                amount))))))))
1701 \f
1702 ;;;; code to disassemble assembler segments
1703
1704 (defun assem-segment-to-disassem-segments (assem-segment dstate)
1705   (declare (type sb!assem:segment assem-segment)
1706            (type disassem-state dstate))
1707   (let ((location 0)
1708         (disassem-segments nil)
1709         (connecting-vec nil))
1710     (sb!assem:on-segment-contents-vectorly
1711      assem-segment
1712      (lambda (seg-code-block)
1713        (multiple-value-setq (disassem-segments location connecting-vec)
1714          (add-block-segments seg-code-block
1715                              disassem-segments
1716                              location
1717                              connecting-vec
1718                              dstate))))
1719     (when connecting-vec
1720       (setf disassem-segments
1721             (add-block-segments nil
1722                                 disassem-segments
1723                                 location
1724                                 connecting-vec
1725                                 dstate)))
1726     (sort disassem-segments #'< :key #'seg-virtual-location)))
1727
1728 ;;; Disassemble the machine code instructions associated with
1729 ;;; ASSEM-SEGMENT (of type assem:segment).
1730 (defun disassemble-assem-segment (assem-segment stream)
1731   (declare (type sb!assem:segment assem-segment)
1732            (type stream stream))
1733   (let* ((dstate (make-dstate))
1734          (disassem-segments
1735           (assem-segment-to-disassem-segments assem-segment dstate)))
1736     (label-segments disassem-segments dstate)
1737     (disassemble-segments disassem-segments stream dstate)))
1738 \f
1739 ;;; routines to find things in the Lisp environment
1740
1741 ;;; an alist of (SYMBOL-SLOT-OFFSET . ACCESS-FUN-NAME) for slots
1742 ;;; in a symbol object that we know about
1743 (defparameter *grokked-symbol-slots*
1744   (sort `((,sb!vm:symbol-value-slot . symbol-value)
1745           (,sb!vm:symbol-plist-slot . symbol-plist)
1746           (,sb!vm:symbol-name-slot . symbol-name)
1747           (,sb!vm:symbol-package-slot . symbol-package))
1748         #'<
1749         :key #'car))
1750
1751 ;;; Given ADDRESS, try and figure out if which slot of which symbol is
1752 ;;; being referred to. Of course we can just give up, so it's not a
1753 ;;; big deal... Return two values, the symbol and the name of the
1754 ;;; access function of the slot.
1755 (defun grok-symbol-slot-ref (address)
1756   (declare (type address address))
1757   (if (not (aligned-p address sb!vm:n-word-bytes))
1758       (values nil nil)
1759       (do ((slots-tail *grokked-symbol-slots* (cdr slots-tail)))
1760           ((null slots-tail)
1761            (values nil nil))
1762         (let* ((field (car slots-tail))
1763                (slot-offset (words-to-bytes (car field)))
1764                (maybe-symbol-addr (- address slot-offset))
1765                (maybe-symbol
1766                 (sb!kernel:make-lisp-obj
1767                  (+ maybe-symbol-addr sb!vm:other-pointer-lowtag))))
1768           (when (symbolp maybe-symbol)
1769             (return (values maybe-symbol (cdr field))))))))
1770
1771 (defvar *address-of-nil-object* (sb!kernel:get-lisp-obj-address nil))
1772
1773 ;;; Given a BYTE-OFFSET from NIL, try and figure out which slot of
1774 ;;; which symbol is being referred to. Of course we can just give up,
1775 ;;; so it's not a big deal... Return two values, the symbol and the
1776 ;;; access function.
1777 (defun grok-nil-indexed-symbol-slot-ref (byte-offset)
1778   (declare (type offset byte-offset))
1779   (grok-symbol-slot-ref (+ *address-of-nil-object* byte-offset)))
1780
1781 ;;; Return the Lisp object located BYTE-OFFSET from NIL.
1782 (defun get-nil-indexed-object (byte-offset)
1783   (declare (type offset byte-offset))
1784   (sb!kernel:make-lisp-obj (+ *address-of-nil-object* byte-offset)))
1785
1786 ;;; Return two values; the Lisp object located at BYTE-OFFSET in the
1787 ;;; constant area of the code-object in the current segment and T, or
1788 ;;; NIL and NIL if there is no code-object in the current segment.
1789 (defun get-code-constant (byte-offset dstate)
1790   #!+sb-doc
1791   (declare (type offset byte-offset)
1792            (type disassem-state dstate))
1793   (let ((code (seg-code (dstate-segment dstate))))
1794     (if code
1795         (values
1796          (sb!kernel:code-header-ref code
1797                                     (ash (+ byte-offset
1798                                             sb!vm:other-pointer-lowtag)
1799                                          (- sb!vm:word-shift)))
1800          t)
1801         (values nil nil))))
1802
1803 (defun get-code-constant-absolute (addr dstate)
1804   (declare (type address addr))
1805   (declare (type disassem-state dstate))
1806   (let ((code (seg-code (dstate-segment dstate))))
1807     (if (null code)
1808       (return-from get-code-constant-absolute (values nil nil)))
1809     (let ((code-size (ash (sb!kernel:get-header-data code) sb!vm:word-shift)))
1810       (sb!sys:without-gcing
1811        (let ((code-addr (- (sb!kernel:get-lisp-obj-address code)
1812                            sb!vm:other-pointer-lowtag)))
1813          (if (or (< addr code-addr) (>= addr (+ code-addr code-size)))
1814            (values nil nil)
1815            (values (sb!kernel:code-header-ref
1816                     code
1817                     (ash (- addr code-addr) (- sb!vm:word-shift)))
1818                    t)))))))
1819
1820 (defvar *assembler-routines-by-addr* nil)
1821
1822 (defvar *foreign-symbols-by-addr* nil)
1823
1824 ;;; Build an address-name hash-table from the name-address hash
1825 (defun invert-address-hash (htable &optional (addr-hash (make-hash-table)))
1826   (maphash (lambda (name address)
1827              (setf (gethash address addr-hash) name))
1828            htable)
1829   addr-hash)
1830
1831 ;;; Return the name of the primitive Lisp assembler routine or foreign
1832 ;;; symbol located at ADDRESS, or NIL if there isn't one.
1833 (defun find-assembler-routine (address)
1834   (declare (type address address))
1835   (when (null *assembler-routines-by-addr*)
1836     (setf *assembler-routines-by-addr*
1837           (invert-address-hash sb!fasl:*assembler-routines*))
1838     (setf *assembler-routines-by-addr*
1839           (invert-address-hash sb!fasl:*static-foreign-symbols*
1840                                *assembler-routines-by-addr*)))
1841   (gethash address *assembler-routines-by-addr*))
1842 \f
1843 ;;;; some handy function for machine-dependent code to use...
1844
1845 #!-sb-fluid (declaim (maybe-inline sap-ref-int read-suffix))
1846
1847 (defun sap-ref-int (sap offset length byte-order)
1848   (declare (type sb!sys:system-area-pointer sap)
1849            (type (unsigned-byte 16) offset)
1850            (type (member 1 2 4) length)
1851            (type (member :little-endian :big-endian) byte-order)
1852            (optimize (speed 3) (safety 0)))
1853   (ecase length
1854     (1 (sb!sys:sap-ref-8 sap offset))
1855     (2 (if (eq byte-order :big-endian)
1856            (+ (ash (sb!sys:sap-ref-8 sap offset) 8)
1857               (sb!sys:sap-ref-8 sap (+ offset 1)))
1858            (+ (ash (sb!sys:sap-ref-8 sap (+ offset 1)) 8)
1859               (sb!sys:sap-ref-8 sap offset))))
1860     (4 (if (eq byte-order :big-endian)
1861            (+ (ash (sb!sys:sap-ref-8 sap offset) 24)
1862               (ash (sb!sys:sap-ref-8 sap (+ 1 offset)) 16)
1863               (ash (sb!sys:sap-ref-8 sap (+ 2 offset)) 8)
1864               (sb!sys:sap-ref-8 sap (+ 3 offset)))
1865            (+ (sb!sys:sap-ref-8 sap offset)
1866               (ash (sb!sys:sap-ref-8 sap (+ 1 offset)) 8)
1867               (ash (sb!sys:sap-ref-8 sap (+ 2 offset)) 16)
1868               (ash (sb!sys:sap-ref-8 sap (+ 3 offset)) 24))))))
1869
1870 (defun read-suffix (length dstate)
1871   (declare (type (member 8 16 32) length)
1872            (type disassem-state dstate)
1873            (optimize (speed 3) (safety 0)))
1874   (let ((length (ecase length (8 1) (16 2) (32 4))))
1875     (declare (type (unsigned-byte 3) length))
1876     (prog1
1877       (sap-ref-int (dstate-segment-sap dstate)
1878                    (dstate-next-offs dstate)
1879                    length
1880                    (dstate-byte-order dstate))
1881       (incf (dstate-next-offs dstate) length))))
1882 \f
1883 ;;;; optional routines to make notes about code
1884
1885 ;;; Store NOTE (which can be either a string or a function with a
1886 ;;; single stream argument) to be printed as an end-of-line comment
1887 ;;; after the current instruction is disassembled.
1888 (defun note (note dstate)
1889   (declare (type (or string function) note)
1890            (type disassem-state dstate))
1891   (push note (dstate-notes dstate)))
1892
1893 (defun prin1-short (thing stream)
1894   (with-print-restrictions
1895     (prin1 thing stream)))
1896
1897 (defun prin1-quoted-short (thing stream)
1898   (if (self-evaluating-p thing)
1899       (prin1-short thing stream)
1900       (prin1-short `',thing stream)))
1901
1902 ;;; Store a note about the lisp constant located BYTE-OFFSET bytes
1903 ;;; from the current code-component, to be printed as an end-of-line
1904 ;;; comment after the current instruction is disassembled.
1905 (defun note-code-constant (byte-offset dstate)
1906   (declare (type offset byte-offset)
1907            (type disassem-state dstate))
1908   (multiple-value-bind (const valid)
1909       (get-code-constant byte-offset dstate)
1910     (when valid
1911       (note (lambda (stream)
1912               (prin1-quoted-short const stream))
1913             dstate))
1914     const))
1915
1916 ;;; Store a note about the lisp constant located at ADDR in the
1917 ;;; current code-component, to be printed as an end-of-line comment
1918 ;;; after the current instruction is disassembled.
1919 (defun note-code-constant-absolute (addr dstate)
1920   (declare (type address addr)
1921            (type disassem-state dstate))
1922   (multiple-value-bind (const valid)
1923       (get-code-constant-absolute addr dstate)
1924     (when valid
1925       (note (lambda (stream)
1926               (prin1-quoted-short const stream))
1927             dstate))
1928     (values const valid)))
1929
1930 ;;; If the memory address located NIL-BYTE-OFFSET bytes from the
1931 ;;; constant NIL is a valid slot in a symbol, store a note describing
1932 ;;; which symbol and slot, to be printed as an end-of-line comment
1933 ;;; after the current instruction is disassembled. Returns non-NIL iff
1934 ;;; a note was recorded.
1935 (defun maybe-note-nil-indexed-symbol-slot-ref (nil-byte-offset dstate)
1936   (declare (type offset nil-byte-offset)
1937            (type disassem-state dstate))
1938   (multiple-value-bind (symbol access-fun)
1939       (grok-nil-indexed-symbol-slot-ref nil-byte-offset)
1940     (when access-fun
1941       (note (lambda (stream)
1942               (prin1 (if (eq access-fun 'symbol-value)
1943                          symbol
1944                          `(,access-fun ',symbol))
1945                      stream))
1946             dstate))
1947     access-fun))
1948
1949 ;;; If the memory address located NIL-BYTE-OFFSET bytes from the
1950 ;;; constant NIL is a valid lisp object, store a note describing which
1951 ;;; symbol and slot, to be printed as an end-of-line comment after the
1952 ;;; current instruction is disassembled. Returns non-NIL iff a note
1953 ;;; was recorded.
1954 (defun maybe-note-nil-indexed-object (nil-byte-offset dstate)
1955   (declare (type offset nil-byte-offset)
1956            (type disassem-state dstate))
1957   (let ((obj (get-nil-indexed-object nil-byte-offset)))
1958     (note (lambda (stream)
1959             (prin1-quoted-short obj stream))
1960           dstate)
1961     t))
1962
1963 ;;; If ADDRESS is the address of a primitive assembler routine or
1964 ;;; foreign symbol, store a note describing which one, to be printed
1965 ;;; as an end-of-line comment after the current instruction is
1966 ;;; disassembled. Returns non-NIL iff a note was recorded. If
1967 ;;; NOTE-ADDRESS-P is non-NIL, a note of the address is also made.
1968 (defun maybe-note-assembler-routine (address note-address-p dstate)
1969   (declare (type disassem-state dstate))
1970   (unless (typep address 'address)
1971     (return-from maybe-note-assembler-routine nil))
1972   (let ((name (find-assembler-routine address)))
1973     (unless (null name)
1974       (note (lambda (stream)
1975               (if note-address-p
1976                   (format stream "#x~8,'0x: ~a" address name)
1977                   (princ name stream)))
1978             dstate))
1979     name))
1980
1981 ;;; If there's a valid mapping from OFFSET in the storage class
1982 ;;; SC-NAME to a source variable, make a note of the source-variable
1983 ;;; name, to be printed as an end-of-line comment after the current
1984 ;;; instruction is disassembled. Returns non-NIL iff a note was
1985 ;;; recorded.
1986 (defun maybe-note-single-storage-ref (offset sc-name dstate)
1987   (declare (type offset offset)
1988            (type symbol sc-name)
1989            (type disassem-state dstate))
1990   (let ((storage-location
1991          (find-valid-storage-location offset sc-name dstate)))
1992     (when storage-location
1993       (note (lambda (stream)
1994               (princ (sb!di:debug-var-symbol
1995                       (aref (storage-info-debug-vars
1996                              (seg-storage-info (dstate-segment dstate)))
1997                             storage-location))
1998                      stream))
1999             dstate)
2000       t)))
2001
2002 ;;; If there's a valid mapping from OFFSET in the storage-base called
2003 ;;; SB-NAME to a source variable, make a note equating ASSOC-WITH with
2004 ;;; the source-variable name, to be printed as an end-of-line comment
2005 ;;; after the current instruction is disassembled. Returns non-NIL iff
2006 ;;; a note was recorded.
2007 (defun maybe-note-associated-storage-ref (offset sb-name assoc-with dstate)
2008   (declare (type offset offset)
2009            (type symbol sb-name)
2010            (type (or symbol string) assoc-with)
2011            (type disassem-state dstate))
2012   (let ((storage-location
2013          (find-valid-storage-location offset sb-name dstate)))
2014     (when storage-location
2015       (note (lambda (stream)
2016               (format stream "~A = ~S"
2017                       assoc-with
2018                       (sb!di:debug-var-symbol
2019                        (aref (dstate-debug-vars dstate)
2020                              storage-location))
2021                       stream))
2022             dstate)
2023       t)))
2024 \f
2025 (defun get-internal-error-name (errnum)
2026   (car (svref sb!c:*backend-internal-errors* errnum)))
2027
2028 (defun get-sc-name (sc-offs)
2029   (sb!c::location-print-name
2030    ;; FIXME: This seems like an awful lot of computation just to get a name.
2031    ;; Couldn't we just use lookup in *BACKEND-SC-NAMES*, without having to cons
2032    ;; up a new object?
2033    (sb!c:make-random-tn :kind :normal
2034                         :sc (svref sb!c:*backend-sc-numbers*
2035                                    (sb!c:sc-offset-scn sc-offs))
2036                         :offset (sb!c:sc-offset-offset sc-offs))))
2037
2038 ;;; When called from an error break instruction's :DISASSEM-CONTROL (or
2039 ;;; :DISASSEM-PRINTER) function, will correctly deal with printing the
2040 ;;; arguments to the break.
2041 ;;;
2042 ;;; ERROR-PARSE-FUN should be a function that accepts:
2043 ;;;   1) a SYSTEM-AREA-POINTER
2044 ;;;   2) a BYTE-OFFSET from the SAP to begin at
2045 ;;;   3) optionally, LENGTH-ONLY, which if non-NIL, means to only return
2046 ;;;      the byte length of the arguments (to avoid unnecessary consing)
2047 ;;; It should read information from the SAP starting at BYTE-OFFSET, and
2048 ;;; return four values:
2049 ;;;   1) the error number
2050 ;;;   2) the total length, in bytes, of the information
2051 ;;;   3) a list of SC-OFFSETs of the locations of the error parameters
2052 ;;;   4) a list of the length (as read from the SAP), in bytes, of each
2053 ;;;      of the return values.
2054 (defun handle-break-args (error-parse-fun stream dstate)
2055   (declare (type function error-parse-fun)
2056            (type (or null stream) stream)
2057            (type disassem-state dstate))
2058   (multiple-value-bind (errnum adjust sc-offsets lengths)
2059       (funcall error-parse-fun
2060                (dstate-segment-sap dstate)
2061                (dstate-next-offs dstate)
2062                (null stream))
2063     (when stream
2064       (setf (dstate-cur-offs dstate)
2065             (dstate-next-offs dstate))
2066       (flet ((emit-err-arg (note)
2067                (let ((num (pop lengths)))
2068                  (print-notes-and-newline stream dstate)
2069                  (print-current-address stream dstate)
2070                  (print-bytes num stream dstate)
2071                  (incf (dstate-cur-offs dstate) num)
2072                  (when note
2073                    (note note dstate)))))
2074         (emit-err-arg nil)
2075         (emit-err-arg (symbol-name (get-internal-error-name errnum)))
2076         (dolist (sc-offs sc-offsets)
2077           (emit-err-arg (get-sc-name sc-offs)))))
2078     (incf (dstate-next-offs dstate)
2079           adjust)))