(invalid-value-debug-var condition)
(invalid-value-frame condition)))))
-(define-condition ambiguous-variable-name (debug-condition)
- ((name :reader ambiguous-variable-name-name :initarg :name)
- (frame :reader ambiguous-variable-name-frame :initarg :frame))
+(define-condition ambiguous-var-name (debug-condition)
+ ((name :reader ambiguous-var-name-name :initarg :name)
+ (frame :reader ambiguous-var-name-frame :initarg :frame))
(:report (lambda (condition stream)
(format stream "~&~S names more than one valid variable in ~S."
- (ambiguous-variable-name-name condition)
- (ambiguous-variable-name-frame condition)))))
+ (ambiguous-var-name-name condition)
+ (ambiguous-var-name-frame condition)))))
\f
;;;; errors and DEBUG-SIGNAL
(symbol (required-argument) :type symbol)
;; a unique integer identification relative to other variables with the same
;; symbol
- (id 0 :type sb!c::index)
+ (id 0 :type index)
;; Does the variable always have a valid value?
(alive-p nil :type boolean))
(def!method print-object ((debug-var debug-var) stream)
(symbol id alive-p sc-offset save-sc-offset))
(:copier nil))
;; storage class and offset (unexported)
- (sc-offset nil :type sb!c::sc-offset)
+ (sc-offset nil :type sb!c:sc-offset)
;; storage class and offset when saved somewhere
- (save-sc-offset nil :type (or sb!c::sc-offset null)))
+ (save-sc-offset nil :type (or sb!c:sc-offset null)))
;;;; frames
(compiler-debug-fun nil :type sb!c::compiled-debug-fun)
;; code object (unexported).
component
- ;; the :FUNCTION-START breakpoint (if any) used to facilitate
+ ;; the :FUN-START breakpoint (if any) used to facilitate
;; function end breakpoints
(end-starter nil :type (or null breakpoint)))
(defstruct (bogus-debug-fun
(:include debug-fun)
(:constructor make-bogus-debug-fun
- (%name &aux (%lambda-list nil) (%debug-vars nil)
- (blocks nil) (%function nil)))
+ (%name &aux
+ (%lambda-list nil)
+ (%debug-vars nil)
+ (blocks nil)
+ (%function nil)))
(:copier nil))
%name)
(elsewhere-p nil :type boolean))
(def!method print-object ((obj debug-block) str)
(print-unreadable-object (obj str :type t)
- (prin1 (debug-block-function-name obj) str)))
+ (prin1 (debug-block-fun-name obj) str)))
#!+sb-doc
(setf (fdocumentation 'debug-block-successors 'function)
;; This is the component in which the breakpoint lies.
component
;; This is the byte offset into the component.
- (offset nil :type sb!c::index)
+ (offset nil :type index)
;; The original instruction replaced by the breakpoint.
(instruction nil :type (or null (unsigned-byte 32)))
;; A list of user breakpoints at this location.
(:copier nil))
;; This is the function invoked when execution encounters the
;; breakpoint. It takes a frame, the breakpoint, and optionally a
- ;; list of values. Values are supplied for :FUNCTION-END breakpoints
+ ;; list of values. Values are supplied for :FUN-END breakpoints
;; as values to return for the function containing the breakpoint.
- ;; :FUNCTION-END breakpoint hook-functions also take a cookie
+ ;; :FUN-END breakpoint hook-functions also take a cookie
;; argument. See COOKIE-FUN slot.
(hook-function nil :type function)
;; CODE-LOCATION or DEBUG-FUN
(what nil :type (or code-location debug-fun))
- ;; :CODE-LOCATION, :FUNCTION-START, or :FUNCTION-END for that kind
+ ;; :CODE-LOCATION, :FUN-START, or :FUN-END for that kind
;; of breakpoint. :UNKNOWN-RETURN-PARTNER if this is the partner of
;; a :code-location breakpoint at an :UNKNOWN-RETURN code-location.
- (kind nil :type (member :code-location :function-start :function-end
+ (kind nil :type (member :code-location :fun-start :fun-end
:unknown-return-partner))
;; Status helps the user and the implementation.
(status :inactive :type (member :active :inactive :deleted))
;; breakpoint for the other one, or NIL if this isn't at an
;; :UNKNOWN-RETURN code location.
(unknown-return-partner nil :type (or null breakpoint))
- ;; :FUNCTION-END breakpoints use a breakpoint at the :FUNCTION-START
+ ;; :FUN-END breakpoints use a breakpoint at the :FUN-START
;; to establish the end breakpoint upon function entry. We do this
;; by frobbing the LRA to jump to a special piece of code that
;; breaks and provides the return values for the returnee. This slot
;; and delete it.
(start-helper nil :type (or null breakpoint))
;; This is a hook users supply to get a dynamically unique cookie
- ;; for identifying :FUNCTION-END breakpoint executions. That is, if
- ;; there is one :FUNCTION-END breakpoint, but there may be multiple
+ ;; for identifying :FUN-END breakpoint executions. That is, if
+ ;; there is one :FUN-END breakpoint, but there may be multiple
;; pending calls of its function on the stack. This function takes
;; the cookie, and the hook-function takes the cookie too.
(cookie-fun nil :type (or null function))
(%debug-block :unparsed :type (or debug-block (member :unparsed)))
;; This is the number of forms processed by the compiler or loader
;; before the top-level form containing this code-location.
- (%tlf-offset :unparsed :type (or sb!c::index (member :unparsed)))
+ (%tlf-offset :unparsed :type (or index (member :unparsed)))
;; This is the depth-first number of the node that begins
;; code-location within its top-level form.
- (%form-number :unparsed :type (or sb!c::index (member :unparsed))))
+ (%form-number :unparsed :type (or index (member :unparsed))))
(def!method print-object ((obj code-location) str)
(print-unreadable-object (obj str :type t)
(prin1 (debug-fun-name (code-location-debug-fun obj))
(:constructor make-compiled-code-location (pc debug-fun))
(:copier nil))
;; an index into DEBUG-FUN's component slot
- (pc nil :type sb!c::index)
+ (pc nil :type index)
;; a bit-vector indexed by a variable's position in
;; DEBUG-FUN-DEBUG-VARS indicating whether the variable has a
;; valid value at this code-location. (unexported).
;;;; frames
;;; This is used in FIND-ESCAPED-FRAME and with the bogus components
-;;; and LRAs used for :function-end breakpoints. When a components
-;;; debug-info slot is :bogus-lra, then the real-lra-slot contains the
+;;; and LRAs used for :FUN-END breakpoints. When a components
+;;; debug-info slot is :BOGUS-LRA, then the REAL-LRA-SLOT contains the
;;; real component to continue executing, as opposed to the bogus
;;; component which appeared in some frame's LRA location.
(defconstant real-lra-slot sb!vm:code-constants-offset)
(defun current-fp () (current-fp))
(defun stack-ref (s n) (stack-ref s n))
(defun %set-stack-ref (s n value) (%set-stack-ref s n value))
-(defun function-code-header (fun) (function-code-header fun))
+(defun fun-code-header (fun) (fun-code-header fun))
(defun lra-code-header (lra) (lra-code-header lra))
(defun make-lisp-obj (value) (make-lisp-obj value))
(defun get-lisp-obj-address (thing) (get-lisp-obj-address thing))
-(defun function-word-offset (fun) (function-word-offset fun))
+(defun fun-word-offset (fun) (fun-word-offset fun))
#!-sb-fluid (declaim (inline cstack-pointer-valid-p))
(defun cstack-pointer-valid-p (x)
(defun component-from-component-ptr (component-ptr)
(declare (type system-area-pointer component-ptr))
(make-lisp-obj (logior (sap-int component-ptr)
- sb!vm:other-pointer-type)))
+ sb!vm:other-pointer-lowtag)))
;;;; X86 support
(let ((component-ptr (component-ptr-from-pc pc)))
(unless (sap= component-ptr (int-sap #x0))
(let* ((code (component-from-component-ptr component-ptr))
- (code-header-len (* (get-header-data code) sb!vm:word-bytes))
+ (code-header-len (* (get-header-data code) sb!vm:n-word-bytes))
(pc-offset (- (sap-int pc)
(- (get-lisp-obj-address code)
- sb!vm:other-pointer-type)
+ sb!vm:other-pointer-lowtag)
code-header-len)))
; (format t "c-lra-fpc ~A ~A ~A~%" pc code pc-offset)
(values pc-offset code)))))
nil)
(t
;; Check the two possible frame pointers.
- (let ((lisp-ocfp (sap-ref-sap fp (- (* (1+ sb!vm::ocfp-save-offset) 4))))
- (lisp-ra (sap-ref-sap fp (- (* (1+ sb!vm::return-pc-save-offset)
+ (let ((lisp-ocfp (sap-ref-sap fp (- (* (1+ ocfp-save-offset) 4))))
+ (lisp-ra (sap-ref-sap fp (- (* (1+ return-pc-save-offset)
4))))
- (c-ocfp (sap-ref-sap fp (* 0 sb!vm:word-bytes)))
- (c-ra (sap-ref-sap fp (* 1 sb!vm:word-bytes))))
+ (c-ocfp (sap-ref-sap fp (* 0 sb!vm:n-word-bytes)))
+ (c-ra (sap-ref-sap fp (* 1 sb!vm:n-word-bytes))))
(cond ((and (sap> lisp-ocfp fp) (cstack-pointer-valid-p lisp-ocfp)
(ra-pointer-valid-p lisp-ra)
(sap> c-ocfp fp) (cstack-pointer-valid-p c-ocfp)
(compute-calling-frame
(descriptor-sap
(get-context-value
- frame sb!vm::ocfp-save-offset
+ frame ocfp-save-offset
(sb!c::compiled-debug-fun-old-fp c-d-f)))
(get-context-value
- frame sb!vm::lra-save-offset
+ frame lra-save-offset
(sb!c::compiled-debug-fun-return-pc c-d-f))
frame)))
(bogus-debug-fun
#!-x86
(compute-calling-frame
#!-alpha
- (sap-ref-sap fp (* sb!vm::ocfp-save-offset
- sb!vm:word-bytes))
+ (sap-ref-sap fp (* ocfp-save-offset
+ sb!vm:n-word-bytes))
#!+alpha
(int-sap
- (sap-ref-32 fp (* sb!vm::ocfp-save-offset
- sb!vm:word-bytes)))
+ (sap-ref-32 fp (* ocfp-save-offset
+ sb!vm:n-word-bytes)))
- (stack-ref fp sb!vm::lra-save-offset)
+ (stack-ref fp lra-save-offset)
frame)))))))
down)))
#!-x86
(defun get-context-value (frame stack-slot loc)
(declare (type compiled-frame frame) (type unsigned-byte stack-slot)
- (type sb!c::sc-offset loc))
+ (type sb!c:sc-offset loc))
(let ((pointer (frame-pointer frame))
(escaped (compiled-frame-escaped frame)))
(if escaped
#!+x86
(defun get-context-value (frame stack-slot loc)
(declare (type compiled-frame frame) (type unsigned-byte stack-slot)
- (type sb!c::sc-offset loc))
+ (type sb!c:sc-offset loc))
(let ((pointer (frame-pointer frame))
(escaped (compiled-frame-escaped frame)))
(if escaped
(sub-access-debug-var-slot pointer loc escaped)
(ecase stack-slot
- (#.sb!vm::ocfp-save-offset
+ (#.ocfp-save-offset
(stack-ref pointer stack-slot))
- (#.sb!vm::lra-save-offset
+ (#.lra-save-offset
(sap-ref-sap pointer (- (* (1+ stack-slot) 4))))))))
#!-x86
(defun (setf get-context-value) (value frame stack-slot loc)
(declare (type compiled-frame frame) (type unsigned-byte stack-slot)
- (type sb!c::sc-offset loc))
+ (type sb!c:sc-offset loc))
(let ((pointer (frame-pointer frame))
(escaped (compiled-frame-escaped frame)))
(if escaped
#!+x86
(defun (setf get-context-value) (value frame stack-slot loc)
(declare (type compiled-frame frame) (type unsigned-byte stack-slot)
- (type sb!c::sc-offset loc))
+ (type sb!c:sc-offset loc))
(let ((pointer (frame-pointer frame))
(escaped (compiled-frame-escaped frame)))
(if escaped
(sub-set-debug-var-slot pointer loc value escaped)
(ecase stack-slot
- (#.sb!vm::ocfp-save-offset
+ (#.ocfp-save-offset
(setf (stack-ref pointer stack-slot) value))
- (#.sb!vm::lra-save-offset
+ (#.lra-save-offset
(setf (sap-ref-sap pointer (- (* (1+ stack-slot) 4))) value))))))
;;; This returns a frame for the one existing in time immediately
(if (fixnump lra)
(let ((fp (frame-pointer up-frame)))
(values lra
- (stack-ref fp (1+ sb!vm::lra-save-offset))))
+ (stack-ref fp (1+ lra-save-offset))))
(values (get-header-data lra)
(lra-code-header lra)))
(if code
(values code
(* (1+ (- word-offset (get-header-data code)))
- sb!vm:word-bytes)
+ sb!vm:n-word-bytes)
nil)
(values :foreign-function
0
(when (null code)
(return (values code 0 context)))
(let* ((code-header-len (* (get-header-data code)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(pc-offset
(- (sap-int (sb!vm:context-pc context))
(- (get-lisp-obj-address code)
- sb!vm:other-pointer-type)
+ sb!vm:other-pointer-lowtag)
code-header-len)))
(/show "got PC-OFFSET")
(unless (<= 0 pc-offset
(* (code-header-ref code sb!vm:code-code-size-slot)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
;; We were in an assembly routine. Therefore, use the
;; LRA as the pc.
;;
(when (symbolp code)
(return (values code 0 scp)))
(let* ((code-header-len (* (get-header-data code)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(pc-offset
(- (sap-int (sb!vm:context-pc scp))
(- (get-lisp-obj-address code)
- sb!vm:other-pointer-type)
+ sb!vm:other-pointer-lowtag)
code-header-len)))
;; Check to see whether we were executing in a branch
;; delay slot.
#!+(or pmax sgi) ; pmax only (and broken anyway)
(when (logbitp 31 (sb!alien:slot scp '%mips::sc-cause))
- (incf pc-offset sb!vm:word-bytes))
+ (incf pc-offset sb!vm:n-word-bytes))
(unless (<= 0 pc-offset
(* (code-header-ref code sb!vm:code-code-size-slot)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
;; We were in an assembly routine. Therefore, use the
;; LRA as the pc.
(setf pc-offset
(declare (type (unsigned-byte 32) bits))
(let ((object (make-lisp-obj bits)))
(if (functionp object)
- (or (function-code-header object)
+ (or (fun-code-header object)
:undefined-function)
(let ((lowtag (get-lowtag object)))
- (if (= lowtag sb!vm:other-pointer-type)
+ (if (= lowtag sb!vm:other-pointer-lowtag)
(let ((type (get-type object)))
- (cond ((= type sb!vm:code-header-type)
+ (cond ((= type sb!vm:code-header-widetag)
object)
- ((= type sb!vm:return-pc-header-type)
+ ((= type sb!vm:return-pc-header-widetag)
(lra-code-header object))
(t
nil))))))))
\f
;;;; frame utilities
-;;; This returns a COMPILED-DEBUG-FUN for code and pc. We fetch
-;;; the SB!C::DEBUG-INFO and run down its function-map to get a
-;;; SB!C::COMPILED-DEBUG-FUN from the pc. The result only needs
-;;; to reference the component, for function constants, and the
+;;; This returns a COMPILED-DEBUG-FUN for code and pc. We fetch the
+;;; SB!C::DEBUG-INFO and run down its FUN-MAP to get a
+;;; SB!C::COMPILED-DEBUG-FUN from the pc. The result only needs to
+;;; reference the component, for function constants, and the
;;; SB!C::COMPILED-DEBUG-FUN.
(defun debug-fun-from-pc (component pc)
(let ((info (%code-debug-info component)))
((eq info :bogus-lra)
(make-bogus-debug-fun "function end breakpoint"))
(t
- (let* ((function-map (get-debug-info-function-map info))
- (len (length function-map)))
- (declare (simple-vector function-map))
+ (let* ((fun-map (get-debug-info-fun-map info))
+ (len (length fun-map)))
+ (declare (type simple-vector fun-map))
(if (= len 1)
- (make-compiled-debug-fun (svref function-map 0) component)
+ (make-compiled-debug-fun (svref fun-map 0) component)
(let ((i 1)
(elsewhere-p
(>= pc (sb!c::compiled-debug-fun-elsewhere-pc
- (svref function-map 0)))))
+ (svref fun-map 0)))))
(declare (type sb!int:index i))
(loop
(when (or (= i len)
(< pc (if elsewhere-p
(sb!c::compiled-debug-fun-elsewhere-pc
- (svref function-map (1+ i)))
- (svref function-map i))))
+ (svref fun-map (1+ i)))
+ (svref fun-map i))))
(return (make-compiled-debug-fun
- (svref function-map (1- i))
+ (svref fun-map (1- i))
component)))
(incf i 2)))))))))
#!-alpha
(sap-ref-sap catch
(* sb!vm:catch-block-current-cont-slot
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
#!+alpha
(:int-sap
(sap-ref-32 catch
(* sb!vm:catch-block-current-cont-slot
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
(let* (#!-x86
(lra (stack-ref catch sb!vm:catch-block-entry-pc-slot))
#!+x86
(ra (sap-ref-sap
catch (* sb!vm:catch-block-entry-pc-slot
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
#!-x86
(component
(stack-ref catch sb!vm:catch-block-current-code-slot))
#!-x86
(* (- (1+ (get-header-data lra))
(get-header-data component))
- sb!vm:word-bytes)
+ sb!vm:n-word-bytes)
#!+x86
(- (sap-int ra)
(- (get-lisp-obj-address component)
- sb!vm:other-pointer-type)
- (* (get-header-data component) sb!vm:word-bytes))))
+ sb!vm:other-pointer-lowtag)
+ (* (get-header-data component) sb!vm:n-word-bytes))))
(push (cons #!-x86
(stack-ref catch sb!vm:catch-block-tag-slot)
#!+x86
(make-lisp-obj
(sap-ref-32 catch (* sb!vm:catch-block-tag-slot
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(make-compiled-code-location
offset (frame-debug-fun frame)))
res)))
#!-alpha
(sap-ref-sap catch
(* sb!vm:catch-block-previous-catch-slot
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
#!+alpha
(:int-sap
(sap-ref-32 catch
(* sb!vm:catch-block-previous-catch-slot
- sb!vm:word-bytes)))))))
+ sb!vm:n-word-bytes)))))))
\f
;;;; operations on DEBUG-FUNs
(sb!c::compiled-debug-fun-start-pc
(compiled-debug-fun-compiler-debug-fun debug-fun))))
(do ((entry (%code-entry-points component)
- (%function-next entry)))
+ (%simple-fun-next entry)))
((null entry) nil)
(when (= start-pc
(sb!c::compiled-debug-fun-start-pc
(defun fun-debug-fun (fun)
(declare (type function fun))
(ecase (get-type fun)
- (#.sb!vm:closure-header-type
- (fun-debug-fun (%closure-function fun)))
- (#.sb!vm:funcallable-instance-header-type
- (fun-debug-fun (funcallable-instance-function fun)))
- ((#.sb!vm:function-header-type #.sb!vm:closure-function-header-type)
- (let* ((name (%function-name fun))
- (component (function-code-header fun))
+ (#.sb!vm:closure-header-widetag
+ (fun-debug-fun (%closure-fun fun)))
+ (#.sb!vm:funcallable-instance-header-widetag
+ (fun-debug-fun (funcallable-instance-fun fun)))
+ ((#.sb!vm:simple-fun-header-widetag
+ #.sb!vm:closure-fun-header-widetag)
+ (let* ((name (%simple-fun-name fun))
+ (component (fun-code-header fun))
(res (find-if
(lambda (x)
(and (sb!c::compiled-debug-fun-p x)
(eq (sb!c::compiled-debug-fun-name x) name)
(eq (sb!c::compiled-debug-fun-kind x) nil)))
- (get-debug-info-function-map
+ (get-debug-info-fun-map
(%code-debug-info component)))))
(if res
(make-compiled-debug-fun res component)
;; works for all named functions anyway.
;; -- WHN 20000120
(debug-fun-from-pc component
- (* (- (function-word-offset fun)
+ (* (- (fun-word-offset fun)
(get-header-data component))
- sb!vm:word-bytes)))))))
+ sb!vm:n-word-bytes)))))))
;;; Return the kind of the function, which is one of :OPTIONAL,
;;; :EXTERNAL, TOP-level, :CLEANUP, or NIL.
(compiled-debug-fun (compiled-debug-fun-lambda-list debug-fun))
(bogus-debug-fun nil)))
-;;; Note: If this has to compute the lambda list, it caches it in
-;;; DEBUG-FUN.
+;;; Note: If this has to compute the lambda list, it caches it in DEBUG-FUN.
(defun compiled-debug-fun-lambda-list (debug-fun)
(let ((lambda-list (debug-fun-%lambda-list debug-fun)))
(cond ((eq lambda-list :unparsed)
(make-array 20 :adjustable t :fill-pointer t))
(defvar *other-parsing-buffer*
(make-array 20 :adjustable t :fill-pointer t))
-;;; PARSE-DEBUG-BLOCKS, PARSE-DEBUG-VARS and UNCOMPACT-FUNCTION-MAP
+;;; PARSE-DEBUG-BLOCKS and PARSE-DEBUG-VARS
;;; use this to unpack binary encoded information. It returns the
;;; values returned by the last form in body.
;;;
(debug-signal 'no-debug-blocks
:debug-fun debug-fun)))))
-;;; This returns a SIMPLE-VECTOR of DEBUG-BLOCKs or NIL. NIL indicates
-;;; there was no basic block information.
+;;; Return a SIMPLE-VECTOR of DEBUG-BLOCKs or NIL. NIL indicates there
+;;; was no basic block information.
(defun parse-debug-blocks (debug-fun)
(etypecase debug-fun
(compiled-debug-fun
;;; This does some of the work of PARSE-DEBUG-BLOCKS.
(defun parse-compiled-debug-blocks (debug-fun)
- (let* ((debug-fun (compiled-debug-fun-compiler-debug-fun
- debug-fun))
- (var-count (length (debug-fun-debug-vars debug-fun)))
- (blocks (sb!c::compiled-debug-fun-blocks debug-fun))
+ (let* ((var-count (length (debug-fun-debug-vars debug-fun)))
+ (compiler-debug-fun (compiled-debug-fun-compiler-debug-fun
+ debug-fun))
+ (blocks (sb!c::compiled-debug-fun-blocks compiler-debug-fun))
;; KLUDGE: 8 is a hard-wired constant in the compiler for the
;; element size of the packed binary representation of the
;; blocks data.
(live-set-len (ceiling var-count 8))
- (tlf-number (sb!c::compiled-debug-fun-tlf-number debug-fun)))
- (unless blocks (return-from parse-compiled-debug-blocks nil))
+ (tlf-number (sb!c::compiled-debug-fun-tlf-number compiler-debug-fun)))
+ (unless blocks
+ (return-from parse-compiled-debug-blocks nil))
(macrolet ((aref+ (a i) `(prog1 (aref ,a ,i) (incf ,i))))
(with-parsing-buffer (blocks-buffer locations-buffer)
(let ((i 0)
\f
;;;; unpacking minimal debug functions
-(eval-when (:compile-toplevel :execute)
-
-;;; sleazoid "macro" to keep our indentation sane in UNCOMPACT-FUNCTION-MAP
-(sb!xc:defmacro make-uncompacted-debug-fun ()
- '(sb!c::make-compiled-debug-fun
- :name
- (let ((base (ecase (ldb sb!c::minimal-debug-fun-name-style-byte
- options)
- (#.sb!c::minimal-debug-fun-name-symbol
- (intern (sb!c::read-var-string map i)
- (sb!c::compiled-debug-info-package info)))
- (#.sb!c::minimal-debug-fun-name-packaged
- (let ((pkg (sb!c::read-var-string map i)))
- (intern (sb!c::read-var-string map i) pkg)))
- (#.sb!c::minimal-debug-fun-name-uninterned
- (make-symbol (sb!c::read-var-string map i)))
- (#.sb!c::minimal-debug-fun-name-component
- (sb!c::compiled-debug-info-name info)))))
- (if (logtest flags sb!c::minimal-debug-fun-setf-bit)
- `(setf ,base)
- base))
- :kind (svref sb!c::*minimal-debug-fun-kinds*
- (ldb sb!c::minimal-debug-fun-kind-byte options))
- :variables
- (when vars-p
- (let ((len (sb!c::read-var-integer map i)))
- (prog1 (subseq map i (+ i len))
- (incf i len))))
- :arguments (when vars-p :minimal)
- :returns
- (ecase (ldb sb!c::minimal-debug-fun-returns-byte options)
- (#.sb!c::minimal-debug-fun-returns-standard
- :standard)
- (#.sb!c::minimal-debug-fun-returns-fixed
- :fixed)
- (#.sb!c::minimal-debug-fun-returns-specified
- (with-parsing-buffer (buf)
- (dotimes (idx (sb!c::read-var-integer map i))
- (vector-push-extend (sb!c::read-var-integer map i) buf))
- (result buf))))
- :return-pc (sb!c::read-var-integer map i)
- :old-fp (sb!c::read-var-integer map i)
- :nfp (when (logtest flags sb!c::minimal-debug-fun-nfp-bit)
- (sb!c::read-var-integer map i))
- :start-pc
- (progn
- (setq code-start-pc (+ code-start-pc (sb!c::read-var-integer map i)))
- (+ code-start-pc (sb!c::read-var-integer map i)))
- :elsewhere-pc
- (setq elsewhere-pc (+ elsewhere-pc (sb!c::read-var-integer map i)))))
-
-) ; EVAL-WHEN
-
-;;; Return a normal function map derived from a minimal debug info
-;;; function map. This involves looping parsing MINIMAL-DEBUG-FUNs and
-;;; then building a vector out of them.
-;;;
-;;; FIXME: This and its helper macro just above become dead code now
-;;; that we no longer use compacted function maps.
-(defun uncompact-function-map (info)
+;;; Return a FUN-MAP for a given COMPILED-DEBUG-INFO object.
+(defun get-debug-info-fun-map (info)
(declare (type sb!c::compiled-debug-info info))
-
- ;; (This is stubified until we solve the problem of representing
- ;; debug information in a way which plays nicely with package renaming.)
- (error "FIXME: dead code UNCOMPACT-FUNCTION-MAP (was stub)")
-
- (let* ((map (sb!c::compiled-debug-info-function-map info))
- (i 0)
- (len (length map))
- (code-start-pc 0)
- (elsewhere-pc 0))
- (declare (type (simple-array (unsigned-byte 8) (*)) map))
- (sb!int:collect ((res))
- (loop
- (when (= i len) (return))
- (let* ((options (prog1 (aref map i) (incf i)))
- (flags (prog1 (aref map i) (incf i)))
- (vars-p (logtest flags
- sb!c::minimal-debug-fun-variables-bit))
- (dfun (make-uncompacted-debug-fun)))
- (res code-start-pc)
- (res dfun)))
-
- (coerce (cdr (res)) 'simple-vector))))
-
-;;; a map from minimal DEBUG-INFO function maps to unpacked
-;;; versions thereof
-(defvar *uncompacted-function-maps* (make-hash-table :test 'eq))
-
-;;; Return a FUNCTION-MAP for a given COMPILED-DEBUG-info object. If
-;;; the info is minimal, and has not been parsed, then parse it.
-;;;
-;;; FIXME: Now that we no longer use the MINIMAL-DEBUG-FUN
-;;; representation, calls to this function can be replaced by calls to
-;;; the bare COMPILED-DEBUG-INFO-FUNCTION-MAP slot accessor function,
-;;; and this function and everything it calls become dead code which
-;;; can be deleted.
-(defun get-debug-info-function-map (info)
- (declare (type sb!c::compiled-debug-info info))
- (let ((map (sb!c::compiled-debug-info-function-map info)))
- (if (simple-vector-p map)
- map
- (or (gethash map *uncompacted-function-maps*)
- (setf (gethash map *uncompacted-function-maps*)
- (uncompact-function-map info))))))
+ (let ((map (sb!c::compiled-debug-info-fun-map info)))
+ ;; The old CMU CL had various hairy possibilities here, but in
+ ;; SBCL we only use this one, right?
+ (aver (simple-vector-p map))
+ ;; So it's easy..
+ map))
\f
;;;; CODE-LOCATIONs
0)))
(svref blocks (1- end)))
(t last))))
- (declare (type sb!c::index i end))
+ (declare (type index i end))
(when (< pc
(compiled-code-location-pc
(svref (compiled-debug-block-code-locations
;;; Return the name of the function represented by DEBUG-FUN.
;;; This may be a string or a cons; do not assume it is a symbol.
-(defun debug-block-function-name (debug-block)
+(defun debug-block-fun-name (debug-block)
(etypecase debug-block
(compiled-debug-block
(let ((code-locs (compiled-debug-block-code-locations debug-block)))
(zerop (logand val 3))
;; character
(and (zerop (logand val #xffff0000)) ; Top bits zero
- (= (logand val #xff) sb!vm:base-char-type)) ; Char tag
+ (= (logand val #xff) sb!vm:base-char-widetag)) ; char tag
;; unbound marker
- (= val sb!vm:unbound-marker-type)
+ (= val sb!vm:unbound-marker-widetag)
;; pointer
(and (logand val 1)
;; Check that the pointer is valid. XXX Could do a better
;; routine in the C runtime support code
(or (< sb!vm:read-only-space-start val
(* sb!vm:*read-only-space-free-pointer*
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(< sb!vm:static-space-start val
(* sb!vm:*static-space-free-pointer*
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(< sb!vm:dynamic-space-start val
(sap-int (dynamic-space-free-pointer))))))
(make-lisp-obj val)
(sb!vm:context-register escaped
sb!vm::nfp-offset))
#!-alpha
- (sb!sys:sap-ref-sap fp (* sb!vm::nfp-save-offset
- sb!vm:word-bytes))
+ (sb!sys:sap-ref-sap fp (* nfp-save-offset
+ sb!vm:n-word-bytes))
#!+alpha
(sb!vm::make-number-stack-pointer
- (sb!sys:sap-ref-32 fp (* sb!vm::nfp-save-offset
- sb!vm:word-bytes))))))
+ (sb!sys:sap-ref-32 fp (* nfp-save-offset
+ sb!vm:n-word-bytes))))))
,@body)))
(ecase (sb!c:sc-offset-scn sc-offset)
((#.sb!vm:any-reg-sc-number
(sb!sys:int-sap val)))
(#.sb!vm:signed-reg-sc-number
(with-escaped-value (val)
- (if (logbitp (1- sb!vm:word-bits) val)
- (logior val (ash -1 sb!vm:word-bits))
+ (if (logbitp (1- sb!vm:n-word-bits) val)
+ (logior val (ash -1 sb!vm:n-word-bits))
val)))
(#.sb!vm:unsigned-reg-sc-number
(with-escaped-value (val)
(#.sb!vm:single-stack-sc-number
(with-nfp (nfp)
(sb!sys:sap-ref-single nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
(#.sb!vm:double-stack-sc-number
(with-nfp (nfp)
(sb!sys:sap-ref-double nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
#!+long-float
(#.sb!vm:long-stack-sc-number
(with-nfp (nfp)
(sb!sys:sap-ref-long nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
(#.sb!vm:complex-single-stack-sc-number
(with-nfp (nfp)
(complex
(sb!sys:sap-ref-single nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(sb!sys:sap-ref-single nfp (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes)))))
+ sb!vm:n-word-bytes)))))
(#.sb!vm:complex-double-stack-sc-number
(with-nfp (nfp)
(complex
(sb!sys:sap-ref-double nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(sb!sys:sap-ref-double nfp (* (+ (sb!c:sc-offset-offset sc-offset) 2)
- sb!vm:word-bytes)))))
+ sb!vm:n-word-bytes)))))
#!+long-float
(#.sb!vm:complex-long-stack-sc-number
(with-nfp (nfp)
(complex
(sb!sys:sap-ref-long nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(sb!sys:sap-ref-long nfp (* (+ (sb!c:sc-offset-offset sc-offset)
#!+sparc 4)
- sb!vm:word-bytes)))))
+ sb!vm:n-word-bytes)))))
(#.sb!vm:control-stack-sc-number
(sb!kernel:stack-ref fp (sb!c:sc-offset-offset sc-offset)))
(#.sb!vm:base-char-stack-sc-number
(with-nfp (nfp)
(code-char (sb!sys:sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes)))))
+ sb!vm:n-word-bytes)))))
(#.sb!vm:unsigned-stack-sc-number
(with-nfp (nfp)
(sb!sys:sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
(#.sb!vm:signed-stack-sc-number
(with-nfp (nfp)
(sb!sys:signed-sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
(#.sb!vm:sap-stack-sc-number
(with-nfp (nfp)
(sb!sys:sap-ref-sap nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes)))))))
+ sb!vm:n-word-bytes)))))))
#!+x86
(defun sub-access-debug-var-slot (fp sc-offset &optional escaped)
(#.sb!vm:signed-reg-sc-number
(/show0 "case of SIGNED-REG-SC-NUMBER")
(with-escaped-value (val)
- (if (logbitp (1- sb!vm:word-bits) val)
- (logior val (ash -1 sb!vm:word-bits))
+ (if (logbitp (1- sb!vm:n-word-bits) val)
+ (logior val (ash -1 sb!vm:n-word-bits))
val)))
(#.sb!vm:unsigned-reg-sc-number
(/show0 "case of UNSIGNED-REG-SC-NUMBER")
(#.sb!vm:single-stack-sc-number
(/show0 "case of SINGLE-STACK-SC-NUMBER")
(sap-ref-single fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
(#.sb!vm:double-stack-sc-number
(/show0 "case of DOUBLE-STACK-SC-NUMBER")
(sap-ref-double fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
#!+long-float
(#.sb!vm:long-stack-sc-number
(/show0 "case of LONG-STACK-SC-NUMBER")
(sap-ref-long fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 3)
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
(#.sb!vm:complex-single-stack-sc-number
(/show0 "case of COMPLEX-STACK-SC-NUMBER")
(complex
(sap-ref-single fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(sap-ref-single fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
- sb!vm:word-bytes)))))
+ sb!vm:n-word-bytes)))))
(#.sb!vm:complex-double-stack-sc-number
(/show0 "case of COMPLEX-DOUBLE-STACK-SC-NUMBER")
(complex
(sap-ref-double fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(sap-ref-double fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 4)
- sb!vm:word-bytes)))))
+ sb!vm:n-word-bytes)))))
#!+long-float
(#.sb!vm:complex-long-stack-sc-number
(/show0 "case of COMPLEX-LONG-STACK-SC-NUMBER")
(complex
(sap-ref-long fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 3)
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(sap-ref-long fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 6)
- sb!vm:word-bytes)))))
+ sb!vm:n-word-bytes)))))
(#.sb!vm:control-stack-sc-number
(/show0 "case of CONTROL-STACK-SC-NUMBER")
(stack-ref fp (sb!c:sc-offset-offset sc-offset)))
(/show0 "case of BASE-CHAR-STACK-SC-NUMBER")
(code-char
(sap-ref-32 fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes)))))
+ sb!vm:n-word-bytes)))))
(#.sb!vm:unsigned-stack-sc-number
(/show0 "case of UNSIGNED-STACK-SC-NUMBER")
(sap-ref-32 fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
(#.sb!vm:signed-stack-sc-number
(/show0 "case of SIGNED-STACK-SC-NUMBER")
(signed-sap-ref-32 fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes))))
+ sb!vm:n-word-bytes))))
(#.sb!vm:sap-stack-sc-number
(/show0 "case of SAP-STACK-SC-NUMBER")
(sap-ref-sap fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes)))))))
+ sb!vm:n-word-bytes)))))))
;;; This stores value as the value of DEBUG-VAR in FRAME. In the
;;; COMPILED-DEBUG-VAR case, access the current value to determine if
sb!vm::nfp-offset))
#!-alpha
(sap-ref-sap fp
- (* sb!vm::nfp-save-offset
- sb!vm:word-bytes))
+ (* nfp-save-offset
+ sb!vm:n-word-bytes))
#!+alpha
(sb!vm::make-number-stack-pointer
(sap-ref-32 fp
- (* sb!vm::nfp-save-offset
- sb!vm:word-bytes))))))
+ (* nfp-save-offset
+ sb!vm:n-word-bytes))))))
,@body)))
(ecase (sb!c:sc-offset-scn sc-offset)
((#.sb!vm:any-reg-sc-number
(#.sb!vm:sap-reg-sc-number
(set-escaped-value (sap-int value)))
(#.sb!vm:signed-reg-sc-number
- (set-escaped-value (logand value (1- (ash 1 sb!vm:word-bits)))))
+ (set-escaped-value (logand value (1- (ash 1 sb!vm:n-word-bits)))))
(#.sb!vm:unsigned-reg-sc-number
(set-escaped-value value))
(#.sb!vm:non-descriptor-reg-sc-number
(#.sb!vm:single-stack-sc-number
(with-nfp (nfp)
(setf (sap-ref-single nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(the single-float value))))
(#.sb!vm:double-stack-sc-number
(with-nfp (nfp)
(setf (sap-ref-double nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(the double-float value))))
#!+long-float
(#.sb!vm:long-stack-sc-number
(with-nfp (nfp)
(setf (sap-ref-long nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(the long-float value))))
(#.sb!vm:complex-single-stack-sc-number
(with-nfp (nfp)
(setf (sap-ref-single
- nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:word-bytes))
+ nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:n-word-bytes))
(the single-float (realpart value)))
(setf (sap-ref-single
nfp (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(the single-float (realpart value)))))
(#.sb!vm:complex-double-stack-sc-number
(with-nfp (nfp)
(setf (sap-ref-double
- nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:word-bytes))
+ nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:n-word-bytes))
(the double-float (realpart value)))
(setf (sap-ref-double
nfp (* (+ (sb!c:sc-offset-offset sc-offset) 2)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(the double-float (realpart value)))))
#!+long-float
(#.sb!vm:complex-long-stack-sc-number
(with-nfp (nfp)
(setf (sap-ref-long
- nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:word-bytes))
+ nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:n-word-bytes))
(the long-float (realpart value)))
(setf (sap-ref-long
nfp (* (+ (sb!c:sc-offset-offset sc-offset) #!+sparc 4)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(the long-float (realpart value)))))
(#.sb!vm:control-stack-sc-number
(setf (stack-ref fp (sb!c:sc-offset-offset sc-offset)) value))
(#.sb!vm:base-char-stack-sc-number
(with-nfp (nfp)
(setf (sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(char-code (the character value)))))
(#.sb!vm:unsigned-stack-sc-number
(with-nfp (nfp)
(setf (sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(the (unsigned-byte 32) value))))
(#.sb!vm:signed-stack-sc-number
(with-nfp (nfp)
(setf (signed-sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(the (signed-byte 32) value))))
(#.sb!vm:sap-stack-sc-number
(with-nfp (nfp)
(setf (sap-ref-sap nfp (* (sb!c:sc-offset-offset sc-offset)
- sb!vm:word-bytes))
+ sb!vm:n-word-bytes))
(the system-area-pointer value)))))))
#!+x86
(#.sb!vm:sap-reg-sc-number
(set-escaped-value (sap-int value)))
(#.sb!vm:signed-reg-sc-number
- (set-escaped-value (logand value (1- (ash 1 sb!vm:word-bits)))))
+ (set-escaped-value (logand value (1- (ash 1 sb!vm:n-word-bits)))))
(#.sb!vm:unsigned-reg-sc-number
(set-escaped-value value))
(#.sb!vm:single-reg-sc-number
(#.sb!vm:single-stack-sc-number
(setf (sap-ref-single
fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(the single-float value)))
(#.sb!vm:double-stack-sc-number
(setf (sap-ref-double
fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(the double-float value)))
#!+long-float
(#.sb!vm:long-stack-sc-number
(setf (sap-ref-long
fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 3)
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(the long-float value)))
(#.sb!vm:complex-single-stack-sc-number
(setf (sap-ref-single
fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(realpart (the (complex single-float) value)))
(setf (sap-ref-single
fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(imagpart (the (complex single-float) value))))
(#.sb!vm:complex-double-stack-sc-number
(setf (sap-ref-double
fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(realpart (the (complex double-float) value)))
(setf (sap-ref-double
fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 4)
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(imagpart (the (complex double-float) value))))
#!+long-float
(#.sb!vm:complex-long-stack-sc-number
(setf (sap-ref-long
fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 3)
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(realpart (the (complex long-float) value)))
(setf (sap-ref-long
fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 6)
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(imagpart (the (complex long-float) value))))
(#.sb!vm:control-stack-sc-number
(setf (stack-ref fp (sb!c:sc-offset-offset sc-offset)) value))
(#.sb!vm:base-char-stack-sc-number
(setf (sap-ref-32 fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(char-code (the character value))))
(#.sb!vm:unsigned-stack-sc-number
(setf (sap-ref-32 fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(the (unsigned-byte 32) value)))
(#.sb!vm:signed-stack-sc-number
(setf (signed-sap-ref-32
- fp (- (* (1+ (sb!c:sc-offset-offset sc-offset)) sb!vm:word-bytes)))
+ fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
+ sb!vm:n-word-bytes)))
(the (signed-byte 32) value)))
(#.sb!vm:sap-stack-sc-number
(setf (sap-ref-sap fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
- sb!vm:word-bytes)))
+ sb!vm:n-word-bytes)))
(the system-area-pointer value))))))
;;; The method for setting and accessing COMPILED-DEBUG-VAR values use
;;; this to determine if the value stored is the actual value or an
;;; indirection cell.
(defun indirect-value-cell-p (x)
- (and (= (get-lowtag x) sb!vm:other-pointer-type)
- (= (get-type x) sb!vm:value-cell-header-type)))
+ (and (= (get-lowtag x) sb!vm:other-pointer-lowtag)
+ (= (get-type x) sb!vm:value-cell-header-widetag)))
;;; Return three values reflecting the validity of DEBUG-VAR's value
;;; at BASIC-CODE-LOCATION:
;;; The returned function takes the frame to get values from as its
;;; argument, and it returns the values of FORM. The returned function
;;; can signal the following conditions: INVALID-VALUE,
-;;; AMBIGUOUS-VARIABLE-NAME, and FRAME-FUN-MISMATCH.
+;;; AMBIGUOUS-VAR-NAME, and FRAME-FUN-MISMATCH.
(defun preprocess-for-eval (form loc)
(declare (type code-location loc))
(let ((n-frame (gensym))
(:valid
(specs `(,name (debug-var-value ',var ,n-frame))))
(:unknown
- (specs `(,name (debug-signal 'invalid-value :debug-var ',var
+ (specs `(,name (debug-signal 'invalid-value
+ :debug-var ',var
:frame ,n-frame))))
(:ambiguous
- (specs `(,name (debug-signal 'ambiguous-variable-name :name ',name
+ (specs `(,name (debug-signal 'ambiguous-var-name
+ :name ',name
:frame ,n-frame)))))))
(let ((res (coerce `(lambda (,n-frame)
(declare (ignorable ,n-frame))
;;;
;;; WHAT and KIND determine where in a function the system invokes
;;; HOOK-FUNCTION. WHAT is either a code-location or a DEBUG-FUN.
-;;; KIND is one of :CODE-LOCATION, :FUNCTION-START, or :FUNCTION-END.
+;;; KIND is one of :CODE-LOCATION, :FUN-START, or :FUN-END.
;;; Since the starts and ends of functions may not have code-locations
;;; representing them, designate these places by supplying WHAT as a
-;;; DEBUG-FUN and KIND indicating the :FUNCTION-START or
-;;; :FUNCTION-END. When WHAT is a DEBUG-FUN and kind is
-;;; :FUNCTION-END, then hook-function must take two additional
+;;; DEBUG-FUN and KIND indicating the :FUN-START or
+;;; :FUN-END. When WHAT is a DEBUG-FUN and kind is
+;;; :FUN-END, then hook-function must take two additional
;;; arguments, a list of values returned by the function and a
-;;; FUNCTION-END-COOKIE.
+;;; FUN-END-COOKIE.
;;;
;;; INFO is information supplied by and used by the user.
;;;
-;;; FUNCTION-END-COOKIE is a function. To implement :FUNCTION-END
+;;; FUN-END-COOKIE is a function. To implement :FUN-END
;;; breakpoints, the system uses starter breakpoints to establish the
-;;; :FUNCTION-END breakpoint for each invocation of the function. Upon
+;;; :FUN-END breakpoint for each invocation of the function. Upon
;;; each entry, the system creates a unique cookie to identify the
;;; invocation, and when the user supplies a function for this
;;; argument, the system invokes it on the frame and the cookie. The
-;;; system later invokes the :FUNCTION-END breakpoint hook on the same
+;;; system later invokes the :FUN-END breakpoint hook on the same
;;; cookie. The user may save the cookie for comparison in the hook
;;; function.
;;;
;;; Signal an error if WHAT is an unknown code-location.
(defun make-breakpoint (hook-function what
- &key (kind :code-location) info function-end-cookie)
+ &key (kind :code-location) info fun-end-cookie)
(etypecase what
(code-location
(when (code-location-unknown-p what)
bpt))
(compiled-debug-fun
(ecase kind
- (:function-start
+ (:fun-start
(%make-breakpoint hook-function what kind info))
- (:function-end
+ (:fun-end
(unless (eq (sb!c::compiled-debug-fun-returns
(compiled-debug-fun-compiler-debug-fun what))
:standard)
- (error ":FUNCTION-END breakpoints are currently unsupported ~
+ (error ":FUN-END breakpoints are currently unsupported ~
for the known return convention."))
(let* ((bpt (%make-breakpoint hook-function what kind info))
(starter (compiled-debug-fun-end-starter what)))
(unless starter
- (setf starter (%make-breakpoint #'list what :function-start nil))
+ (setf starter (%make-breakpoint #'list what :fun-start nil))
(setf (breakpoint-hook-function starter)
- (function-end-starter-hook starter what))
+ (fun-end-starter-hook starter what))
(setf (compiled-debug-fun-end-starter what) starter))
(setf (breakpoint-start-helper bpt) starter)
(push bpt (breakpoint-%info starter))
- (setf (breakpoint-cookie-fun bpt) function-end-cookie)
+ (setf (breakpoint-cookie-fun bpt) fun-end-cookie)
bpt))))))
;;; These are unique objects created upon entry into a function by a
-;;; :FUNCTION-END breakpoint's starter hook. These are only created
-;;; when users supply :FUNCTION-END-COOKIE to MAKE-BREAKPOINT. Also,
-;;; the :FUNCTION-END breakpoint's hook is called on the same cookie
+;;; :FUN-END breakpoint's starter hook. These are only created
+;;; when users supply :FUN-END-COOKIE to MAKE-BREAKPOINT. Also,
+;;; the :FUN-END breakpoint's hook is called on the same cookie
;;; when it is created.
-(defstruct (function-end-cookie
+(defstruct (fun-end-cookie
(:print-object (lambda (obj str)
(print-unreadable-object (obj str :type t))))
- (:constructor make-function-end-cookie (bogus-lra debug-fun))
+ (:constructor make-fun-end-cookie (bogus-lra debug-fun))
(:copier nil))
- ;; a pointer to the bogus-lra created for :FUNCTION-END breakpoints
+ ;; a pointer to the bogus-lra created for :FUN-END breakpoints
bogus-lra
;; the DEBUG-FUN associated with this cookie
debug-fun)
;;; This maps bogus-lra-components to cookies, so that
-;;; HANDLE-FUNCTION-END-BREAKPOINT can find the appropriate cookie for the
+;;; HANDLE-FUN-END-BREAKPOINT can find the appropriate cookie for the
;;; breakpoint hook.
-(defvar *function-end-cookies* (make-hash-table :test 'eq))
+(defvar *fun-end-cookies* (make-hash-table :test 'eq))
;;; This returns a hook function for the start helper breakpoint
-;;; associated with a :FUNCTION-END breakpoint. The returned function
+;;; associated with a :FUN-END breakpoint. The returned function
;;; makes a fake LRA that all returns go through, and this piece of
;;; fake code actually breaks. Upon return from the break, the code
;;; provides the returnee with any values. Since the returned function
;;; effectively activates FUN-END-BPT on each entry to DEBUG-FUN's
;;; function, we must establish breakpoint-data about FUN-END-BPT.
-(defun function-end-starter-hook (starter-bpt debug-fun)
+(defun fun-end-starter-hook (starter-bpt debug-fun)
(declare (type breakpoint starter-bpt)
(type compiled-debug-fun debug-fun))
#'(lambda (frame breakpoint)
(multiple-value-bind (lra component offset)
(make-bogus-lra
(get-context-value frame
- sb!vm::lra-save-offset
+ lra-save-offset
lra-sc-offset))
(setf (get-context-value frame
- sb!vm::lra-save-offset
+ lra-save-offset
lra-sc-offset)
lra)
(let ((end-bpts (breakpoint-%info starter-bpt)))
(setf (breakpoint-data-breakpoints data) end-bpts)
(dolist (bpt end-bpts)
(setf (breakpoint-internal-data bpt) data)))
- (let ((cookie (make-function-end-cookie lra debug-fun)))
- (setf (gethash component *function-end-cookies*) cookie)
+ (let ((cookie (make-fun-end-cookie lra debug-fun)))
+ (setf (gethash component *fun-end-cookies*) cookie)
(dolist (bpt end-bpts)
(let ((fun (breakpoint-cookie-fun bpt)))
(when fun (funcall fun frame cookie))))))))))
-;;; This takes a FUNCTION-END-COOKIE and a frame, and it returns
+;;; This takes a FUN-END-COOKIE and a frame, and it returns
;;; whether the cookie is still valid. A cookie becomes invalid when
;;; the frame that established the cookie has exited. Sometimes cookie
;;; holders are unaware of cookie invalidation because their
-;;; :FUNCTION-END breakpoint hooks didn't run due to THROW'ing.
+;;; :FUN-END breakpoint hooks didn't run due to THROW'ing.
;;;
;;; This takes a frame as an efficiency hack since the user probably
;;; has a frame object in hand when using this routine, and it saves
;;; repeated parsing of the stack and consing when asking whether a
;;; series of cookies is valid.
-(defun function-end-cookie-valid-p (frame cookie)
- (let ((lra (function-end-cookie-bogus-lra cookie))
+(defun fun-end-cookie-valid-p (frame cookie)
+ (let ((lra (fun-end-cookie-bogus-lra cookie))
(lra-sc-offset (sb!c::compiled-debug-fun-return-pc
(compiled-debug-fun-compiler-debug-fun
- (function-end-cookie-debug-fun cookie)))))
+ (fun-end-cookie-debug-fun cookie)))))
(do ((frame frame (frame-down frame)))
((not frame) nil)
(when (and (compiled-frame-p frame)
- (eq lra
- (get-context-value frame
- sb!vm::lra-save-offset
- lra-sc-offset)))
+ (#-x86 eq #+x86 sap=
+ lra
+ (get-context-value frame lra-save-offset lra-sc-offset)))
(return t)))))
\f
;;;; ACTIVATE-BREAKPOINT
;; (There used to be more cases back before sbcl-0.7.0, when
;; we did special tricks to debug the IR1 interpreter.)
)))
- (:function-start
+ (:fun-start
(etypecase (breakpoint-what breakpoint)
(compiled-debug-fun
- (activate-compiled-function-start-breakpoint breakpoint))
+ (activate-compiled-fun-start-breakpoint breakpoint))
;; (There used to be more cases back before sbcl-0.7.0, when
;; we did special tricks to debug the IR1 interpreter.)
))
- (:function-end
+ (:fun-end
(etypecase (breakpoint-what breakpoint)
(compiled-debug-fun
(let ((starter (breakpoint-start-helper breakpoint)))
(unless (eq (breakpoint-status starter) :active)
- ;; may already be active by some other :FUNCTION-END breakpoint
- (activate-compiled-function-start-breakpoint starter)))
+ ;; may already be active by some other :FUN-END breakpoint
+ (activate-compiled-fun-start-breakpoint starter)))
(setf (breakpoint-status breakpoint) :active))
;; (There used to be more cases back before sbcl-0.7.0, when
;; we did special tricks to debug the IR1 interpreter.)
sb!vm:single-value-return-byte-offset
0))))))
-(defun activate-compiled-function-start-breakpoint (breakpoint)
+(defun activate-compiled-fun-start-breakpoint (breakpoint)
(declare (type breakpoint breakpoint))
(let ((debug-fun (breakpoint-what breakpoint)))
(sub-activate-breakpoint
breakpoint)
(defun deactivate-compiled-breakpoint (breakpoint)
- (if (eq (breakpoint-kind breakpoint) :function-end)
+ (if (eq (breakpoint-kind breakpoint) :fun-end)
(let ((starter (breakpoint-start-helper breakpoint)))
(unless (find-if #'(lambda (bpt)
(and (not (eq bpt breakpoint))
(let ((other (breakpoint-unknown-return-partner breakpoint)))
(when other
(setf (breakpoint-status other) :deleted)))
- (when (eq (breakpoint-kind breakpoint) :function-end)
+ (when (eq (breakpoint-kind breakpoint) :fun-end)
(let* ((starter (breakpoint-start-helper breakpoint))
(breakpoints (delete breakpoint
(the list (breakpoint-info starter)))))
offset))
(let ((breakpoints (breakpoint-data-breakpoints data)))
(if (or (null breakpoints)
- (eq (breakpoint-kind (car breakpoints)) :function-end))
- (handle-function-end-breakpoint-aux breakpoints data signal-context)
+ (eq (breakpoint-kind (car breakpoints)) :fun-end))
+ (handle-fun-end-breakpoint-aux breakpoints data signal-context)
(handle-breakpoint-aux breakpoints data
offset component signal-context)))))
;;; This holds breakpoint-datas while invoking the breakpoint hooks
;;; associated with that particular component and location. While they
;;; are executing, if we hit the location again, we ignore the
-;;; breakpoint to avoid infinite recursion. Function-end breakpoints
+;;; breakpoint to avoid infinite recursion. fun-end breakpoints
;;; must work differently since the breakpoint-data is unique for each
;;; invocation.
(defvar *executing-breakpoint-hooks* nil)
-;;; This handles code-location and DEBUG-FUN :FUNCTION-START
+;;; This handles code-location and DEBUG-FUN :FUN-START
;;; breakpoints.
(defun handle-breakpoint-aux (breakpoints data offset component signal-context)
(/show0 "entering HANDLE-BREAKPOINT-AUX")
(breakpoint-unknown-return-partner bpt)
bpt)))))
-(defun handle-function-end-breakpoint (offset component context)
- (/show0 "entering HANDLE-FUNCTION-END-BREAKPOINT")
+(defun handle-fun-end-breakpoint (offset component context)
+ (/show0 "entering HANDLE-FUN-END-BREAKPOINT")
(let ((data (breakpoint-data component offset nil)))
(unless data
(error "unknown breakpoint in ~S at offset ~S"
offset))
(let ((breakpoints (breakpoint-data-breakpoints data)))
(when breakpoints
- (aver (eq (breakpoint-kind (car breakpoints)) :function-end))
- (handle-function-end-breakpoint-aux breakpoints data context)))))
+ (aver (eq (breakpoint-kind (car breakpoints)) :fun-end))
+ (handle-fun-end-breakpoint-aux breakpoints data context)))))
-;;; Either HANDLE-BREAKPOINT calls this for :FUNCTION-END breakpoints
-;;; [old C code] or HANDLE-FUNCTION-END-BREAKPOINT calls this directly
+;;; Either HANDLE-BREAKPOINT calls this for :FUN-END breakpoints
+;;; [old C code] or HANDLE-FUN-END-BREAKPOINT calls this directly
;;; [new C code].
-(defun handle-function-end-breakpoint-aux (breakpoints data signal-context)
- (/show0 "entering HANDLE-FUNCTION-END-BREAKPOINT-AUX")
+(defun handle-fun-end-breakpoint-aux (breakpoints data signal-context)
+ (/show0 "entering HANDLE-FUN-END-BREAKPOINT-AUX")
(delete-breakpoint-data data)
(let* ((scp
(locally
(frame (do ((cfp (sb!vm:context-register scp sb!vm::cfp-offset))
(f (top-frame) (frame-down f)))
((= cfp (sap-int (frame-pointer f))) f)
- (declare (type (unsigned-byte #.sb!vm:word-bits) cfp))))
+ (declare (type (unsigned-byte #.sb!vm:n-word-bits) cfp))))
(component (breakpoint-data-component data))
- (cookie (gethash component *function-end-cookies*)))
- (remhash component *function-end-cookies*)
+ (cookie (gethash component *fun-end-cookies*)))
+ (remhash component *fun-end-cookies*)
(dolist (bpt breakpoints)
(funcall (breakpoint-hook-function bpt)
frame bpt
- (get-function-end-breakpoint-values scp)
+ (get-fun-end-breakpoint-values scp)
cookie))))
-(defun get-function-end-breakpoint-values (scp)
+(defun get-fun-end-breakpoint-values (scp)
(let ((ocfp (int-sap (sb!vm:context-register
scp
#!-x86 sb!vm::ocfp-offset
results)))
(nreverse results)))
\f
-;;;; MAKE-BOGUS-LRA (used for :FUNCTION-END breakpoints)
+;;;; MAKE-BOGUS-LRA (used for :FUN-END breakpoints)
(defconstant bogus-lra-constants
#!-x86 2 #!+x86 3)
;;; instruction.
(defun make-bogus-lra (real-lra &optional known-return-p)
(without-gcing
- (let* ((src-start (foreign-symbol-address "function_end_breakpoint_guts"))
- (src-end (foreign-symbol-address "function_end_breakpoint_end"))
- (trap-loc (foreign-symbol-address "function_end_breakpoint_trap"))
+ (let* ((src-start (foreign-symbol-address "fun_end_breakpoint_guts"))
+ (src-end (foreign-symbol-address "fun_end_breakpoint_end"))
+ (trap-loc (foreign-symbol-address "fun_end_breakpoint_trap"))
(length (sap- src-end src-start))
(code-object
(%primitive
(setf (code-header-ref code-object (1+ real-lra-slot)) offset))
(setf (code-header-ref code-object known-return-p-slot)
known-return-p)
- (system-area-copy src-start 0 dst-start 0 (* length sb!vm:byte-bits))
+ (system-area-copy src-start 0 dst-start 0 (* length sb!vm:n-byte-bits))
(sb!vm:sanctify-for-execution code-object)
#!+x86
(values dst-start code-object (sap- trap-loc src-start))
#!-x86
(let ((new-lra (make-lisp-obj (+ (sap-int dst-start)
- sb!vm:other-pointer-type))))
+ sb!vm:other-pointer-lowtag))))
(set-header-data
new-lra
(logandc2 (+ sb!vm:code-constants-offset bogus-lra-constants 1)