X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fdebug-info.lisp;h=5ef9dee22188f098020dee7a7abbd405a4eef350;hb=0051cc0532da9f68a0ba5db5c07ebee1c91ee4d8;hp=d71f547975d839519db0aa800db501bcda8e3bdd;hpb=5ec8d0c1c8b7939818b75118b472fac1af554f9a;p=sbcl.git diff --git a/src/code/debug-info.lisp b/src/code/debug-info.lisp index d71f547..5ef9dee 100644 --- a/src/code/debug-info.lisp +++ b/src/code/debug-info.lisp @@ -11,27 +11,11 @@ (in-package "SB!C") -;;;; SC-OFFSETs -;;;; -;;;; We represent the place where some value is stored with a SC-OFFSET, -;;;; which is the SC number and offset encoded as an integer. - -(defconstant-eqx sc-offset-scn-byte (byte 5 0) #'equalp) -(defconstant-eqx sc-offset-offset-byte (byte 22 5) #'equalp) -(def!type sc-offset () '(unsigned-byte 27)) - -(defmacro make-sc-offset (scn offset) - `(dpb ,scn sc-offset-scn-byte - (dpb ,offset sc-offset-offset-byte 0))) - -(defmacro sc-offset-scn (sco) `(ldb sc-offset-scn-byte ,sco)) -(defmacro sc-offset-offset (sco) `(ldb sc-offset-offset-byte ,sco)) - ;;;; flags for compiled debug variables ;;; FIXME: old CMU CL representation follows: ;;; Compiled debug variables are in a packed binary representation in the -;;; DEBUG-FUN-VARIABLES: +;;; DEBUG-FUN-VARS: ;;; single byte of boolean flags: ;;; uninterned name ;;; packaged name @@ -46,16 +30,16 @@ ;;; ...package name bytes...] ;;; [If has ID, ID as var-length integer] ;;; SC-Offset of primary location (as var-length integer) -;;; [If has save SC, SC-Offset of save location (as var-length integer)] +;;; [If has save SC, SC-OFFSET of save location (as var-length integer)] ;;; FIXME: The first two are no longer used in SBCL. ;;;(defconstant compiled-debug-var-uninterned #b00000001) ;;;(defconstant compiled-debug-var-packaged #b00000010) -(defconstant compiled-debug-var-environment-live #b00000100) -(defconstant compiled-debug-var-save-loc-p #b00001000) -(defconstant compiled-debug-var-id-p #b00010000) -(defconstant compiled-debug-var-minimal-p #b00100000) -(defconstant compiled-debug-var-deleted-p #b01000000) +(def!constant compiled-debug-var-environment-live #b00000100) +(def!constant compiled-debug-var-save-loc-p #b00001000) +(def!constant compiled-debug-var-id-p #b00010000) +(def!constant compiled-debug-var-minimal-p #b00100000) +(def!constant compiled-debug-var-deleted-p #b01000000) ;;;; compiled debug blocks ;;;; @@ -74,7 +58,7 @@ ;;;; tuples... (defconstant-eqx compiled-debug-block-nsucc-byte (byte 2 0) #'equalp) -(defconstant compiled-debug-block-elsewhere-p #b00000100) +(def!constant compiled-debug-block-elsewhere-p #b00000100) (defconstant-eqx compiled-code-location-kind-byte (byte 3 0) #'equalp) (defparameter *compiled-code-location-kinds* @@ -87,8 +71,18 @@ (def!struct (compiled-debug-fun (:include debug-fun) #-sb-xc-host (:pure t)) - ;; The name of this function. If from a DEFUN, etc., then this is the - ;; function name, otherwise it is a descriptive string. + ;; KLUDGE: Courtesy of more than a decade of, ah, organic growth in + ;; CMU CL, there are two distinct -- but coupled -- mechanisms to + ;; finding the name of a function. The slot here is one mechanism + ;; (used in CMU CL to look up names in the debugger, e.g. in + ;; BACKTRACE). The other mechanism is the the NAME slot in function + ;; primitive objects (used in CMU CL to look up names elsewhere, + ;; e.g. in CL:FUNCTION-LAMBDA-EXPRESSION and in CL:DESCRIBE). + ;; + ;; They're coupled by the way that DEBUG-FUN objects are looked up. + ;; A list of DEBUG-FUN objects is maintained for each COMPONENT. To + ;; figure out which DEBUG-FUN object corresponds to your FUNCTION + ;; object, you compare the name values of each. -- WHN 2001-12-20 (name (missing-arg) :type (or simple-string cons symbol)) ;; The kind of function (same as FUNCTIONAL-KIND): (kind nil :type (member nil :optional :external :toplevel :cleanup)) @@ -108,17 +102,18 @@ ;; * the variable ID, when it has one ;; * SC-offset of primary location, if it has one ;; * SC-offset of save location, if it has one - (variables nil :type (or simple-vector null)) + (vars nil :type (or simple-vector null)) ;; a vector of the packed binary representation of the ;; COMPILED-DEBUG-BLOCKs in this function, in the order that the ;; blocks were emitted. The first block is the start of the ;; function. This slot may be NIL to save space. ;; - ;; FIXME: The "packed binary representation" description in the comment - ;; above is the same as the description of the old representation of - ;; VARIABLES which doesn't work properly in SBCL (because it doesn't - ;; transform correctly under package renaming). Check whether this slot's - ;; data might have the same problem that that slot's data did. + ;; FIXME: The "packed binary representation" description in the + ;; comment above is the same as the description of the old + ;; representation of VARIABLES which doesn't work properly in SBCL + ;; (because it doesn't transform correctly under package renaming). + ;; Check whether this slot's data might have the same problem that + ;; that slot's data did. (blocks nil :type (or (simple-array (unsigned-byte 8) (*)) null)) ;; If all code locations in this function are in the same top level ;; form, then this is the number of that form, otherwise NIL. If @@ -153,31 +148,31 @@ ;; The following location is the value of the &KEY argument with the ;; specified name. ;; - ;; This may be NIL to save space. If no symbols are present, then this will - ;; be represented with an I-vector with sufficiently large element type. If - ;; this is :MINIMAL, then this means that the VARIABLES are all required - ;; arguments, and are in the order they appear in the VARIABLES vector. In - ;; other words, :MINIMAL stands in for a vector where every element holds its - ;; index. + ;; This may be NIL to save space. If no symbols are present, then + ;; this will be represented with an I-vector with sufficiently large + ;; element type. If this is :MINIMAL, then this means that the + ;; VARIABLES are all required arguments, and are in the order they + ;; appear in the VARIABLES vector. In other words, :MINIMAL stands + ;; in for a vector where every element holds its index. (arguments nil :type (or (simple-array * (*)) (member :minimal nil))) ;; There are three alternatives for this slot: ;; - ;; A vector + ;; a VECTOR ;; A vector of SC-OFFSETS describing the return locations. The ;; vector element type is chosen to hold the largest element. ;; - ;; :Standard + ;; :STANDARD ;; The function returns using the standard unknown-values convention. ;; - ;; :Fixed + ;; :FIXED ;; The function returns using the fixed-values convention, but ;; in order to save space, we elected not to store a vector. (returns :fixed :type (or (simple-array * (*)) (member :standard :fixed))) - ;; SC-Offsets describing where the return PC and return FP are kept. + ;; SC-OFFSETs describing where the return PC and return FP are kept. (return-pc (missing-arg) :type sc-offset) (old-fp (missing-arg) :type sc-offset) - ;; SC-Offset for the number stack FP in this function, or NIL if no NFP - ;; allocated. + ;; SC-OFFSET for the number stack FP in this function, or NIL if no + ;; NFP allocated. (nfp nil :type (or sc-offset null)) ;; The earliest PC in this function at which the environment is properly ;; initialized (arguments moved from passing locations, etc.) @@ -231,7 +226,7 @@ ;;; ### For functions with XEPs, name could be represented more simply ;;; and compactly as some sort of info about with how to find the -;;; FUNCTION-ENTRY that this is a function for. Actually, you really +;;; function entry that this is a function for. Actually, you really ;;; hardly need any info. You can just chain through the functions in ;;; the component until you find the right one. Well, I guess you need ;;; to at least know which function is an XEP for the real function @@ -281,7 +276,7 @@ (def!struct (compiled-debug-info (:include debug-info) #-sb-xc-host (:pure t)) - ;; a simple-vector of alternating DEBUG-FUN objects and fixnum + ;; a SIMPLE-VECTOR of alternating DEBUG-FUN objects and fixnum ;; PCs, used to map PCs to functions, so that we can figure out what ;; function we were running in. Each function is valid between the ;; PC before it (inclusive) and the PC after it (exclusive). The PCs