source: trunk/source/lib/backtrace.lisp @ 14119

Last change on this file since 14119 was 14119, checked in by gb, 9 years ago

Changes from ARM branch. Need testing ...

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 29.2 KB
Line 
1;;;-*-Mode: LISP; Package: CCL -*-
2;;;
3;;;   Copyright (C) 2009 Clozure Associates
4;;;   Copyright (C) 1994-2001 Digitool, Inc
5;;;   This file is part of Clozure CL. 
6;;;
7;;;   Clozure CL is licensed under the terms of the Lisp Lesser GNU Public
8;;;   License , known as the LLGPL and distributed with Clozure CL as the
9;;;   file "LICENSE".  The LLGPL consists of a preamble and the LGPL,
10;;;   which is distributed with Clozure CL as the file "LGPL".  Where these
11;;;   conflict, the preamble takes precedence. 
12;;;
13;;;   Clozure CL is referenced in the preamble as the "LIBRARY."
14;;;
15;;;   The LLGPL is also available online at
16;;;   http://opensource.franz.com/preamble.html
17
18;;; backtrace.lisp
19;;; low-level support for stack-backtrace printing
20
21(in-package "CCL")
22
23#+ppc-target (require "PPC-BACKTRACE")
24#+x86-target (require "X86-BACKTRACE")
25#+arm-target (require "ARM-BACKTRACE")
26
27
28(defparameter *backtrace-show-internal-frames* nil)
29(defparameter *backtrace-print-level* 2)
30(defparameter *backtrace-print-length* 5)
31
32(defparameter *backtrace-format* #+ccl-qres :direct #-ccl-qres :traditional
33  "If :TRADITIONAL, shows calls to non-toplevel functions using FUNCALL, and shows frame address values.
34   If :DIRECT, uses a more streamlined format.")
35
36(defun context-for-suspended-tcr (tcr)
37  (let ((frame-ptr (%tcr-frame-ptr tcr)))
38    (new-backtrace-info nil
39                        frame-ptr ;; youngest - not used
40                        frame-ptr ;; oldest - not used
41                        tcr
42                        nil       ;; condition - not used
43                        frame-ptr ;; current
44                        #+ppc-target *fake-stack-frames*
45                        #+(or x86-target arm-target) frame-ptr
46                        (%fixnum-ref tcr target::tcr.db-link)
47                        0         ;; break level - not used
48                        )))
49 
50
51(defun backtrace-as-list (&key
52                          context
53                          process
54                          origin
55                          (count target::target-most-positive-fixnum)
56                          (start-frame-number 0)
57                          (print-level *backtrace-print-level*)
58                          (print-length *backtrace-print-length*)
59                          (show-internal-frames *backtrace-show-internal-frames*))
60  "Returns a list representing the backtrace.
61Each element in the list is a list that describes the call in one stack frame:
62   (function arg1 arg2 ...)
63The arguments are represented by strings, the function is a symbol or a function
64object."
65  (let* ((*backtrace-print-level* print-level)
66         (*backtrace-print-length* print-length)
67         (*backtrace-format* :list)
68         (result nil))
69    (map-call-frames (lambda (p context)
70                       (multiple-value-bind (lfun pc) (cfp-lfun p)
71                         (push (if lfun
72                                 (backtrace-call-arguments context p lfun pc)
73                                 "?????")
74                               result)))
75                     :context context
76                     :process process
77                     :origin origin
78                     :count count
79                     :start-frame-number start-frame-number
80                     :test (and (not show-internal-frames) 'function-frame-p))
81    (nreverse result)))
82
83(defun print-call-history (&key context
84                                process
85                                origin
86                                (detailed-p t)
87                                (count target::target-most-positive-fixnum)
88                                (start-frame-number 0)
89                                (stream *debug-io*)
90                                (print-level *backtrace-print-level*)
91                                (print-length *backtrace-print-length*)
92                                (show-internal-frames *backtrace-show-internal-frames*)
93                                (format *backtrace-format*))
94  (let ((*backtrace-print-level* print-level)
95        (*backtrace-print-length* print-length)
96        (*backtrace-format* format)
97        (*standard-output* stream)
98        (*print-circle* nil)
99        (frame-number (or start-frame-number 0)))
100    (map-call-frames (lambda (p context)
101                       (multiple-value-bind (lfun pc) (cfp-lfun p)
102                         (unless (and (typep detailed-p 'fixnum)
103                                      (not (= (the fixnum detailed-p) frame-number)))
104                           (%show-stack-frame-label frame-number p context lfun pc detailed-p)
105                           (when detailed-p
106                             (if (or (eq detailed-p :raw) (null lfun))
107                               (%show-stack-frame p context lfun pc)
108                               (%show-args-and-locals p context lfun pc)))
109                           (incf frame-number))))
110                     :context context
111                     :process process
112                     :origin origin
113                     :count count
114                     :start-frame-number start-frame-number
115                     :test (and (not show-internal-frames) 'function-frame-p))
116    (values)))
117
118(defun function-frame-p (p context)
119  (and (not (catch-csp-p p context)) (cfp-lfun p)))
120
121(defun map-call-frames (fn &key context
122                           process
123                           origin
124                           (count target::target-most-positive-fixnum)
125                           (start-frame-number 0)
126                           test)
127  (when (and context process (neq (bt.tcr context) (process-tcr process)))
128    (error "Context ~s doesn't correspond to the process ~s" context process))
129  (let ((tcr (cond (context (bt.tcr context))
130                   (process (process-tcr process))
131                   (t (%current-tcr))))
132        (*print-catch-errors* t)
133        (*signal-printing-errors* nil))
134    (if (eq tcr (%current-tcr))
135      (%map-call-frames-internal fn context (or origin (%get-frame-ptr)) count start-frame-number test)
136      (unwind-protect
137           (progn
138             (%suspend-tcr tcr)
139             (when (null context)
140               (setq context (context-for-suspended-tcr tcr)))
141             (%map-call-frames-internal fn context (or origin (bt.current context))  count start-frame-number test))
142        (%resume-tcr tcr))))
143  nil)
144
145; RAW case
146(defun %show-stack-frame (p context lfun pc)
147  (handler-case
148      (multiple-value-bind (count vsp parent-vsp) (count-values-in-frame p context)
149        (declare (fixnum count))
150        (dotimes (i count)
151          (multiple-value-bind (var type name) 
152                               (nth-value-in-frame p i context lfun pc vsp parent-vsp)
153            (format t "~&  ~D " i)
154            (when name (format t "~s" name))
155            (let* ((*print-length* *backtrace-print-length*)
156                   (*print-level* *backtrace-print-level*))
157              (format t ": ~s" var))
158            (when type (format t " (~S)" type)))))
159    (error () (format t "#<error printing frame>")))
160  (terpri)
161  (terpri))
162
163(defun %show-args-and-locals (p context lfun pc)
164  (handler-case
165      (let* ((unavailable (cons nil nil)))
166        (multiple-value-bind (args locals) (arguments-and-locals context p lfun pc unavailable)
167          (case *backtrace-format*
168            (:direct
169               (format t "~&     Arguments: ~:s" (arglist-from-map lfun)))
170            (t (format t "~&  ~s" (arglist-from-map lfun))))
171          (let* ((*print-length* *backtrace-print-length*)
172                 (*print-level* *backtrace-print-level*))
173            (flet ((show-pair (pair prefix)
174                     (destructuring-bind (name . val) pair
175                       (format t "~&~a~s: " prefix name)
176                       (if (eq val unavailable)
177                         (format t "#<Unavailable>")
178                         (format t "~s" val)))))
179              (case *backtrace-format*
180                (:direct
181                   (when args
182                     (dolist (arg args)
183                       (show-pair arg "       ")))
184                   (when locals
185                     ;; This shows all bindings (including specials), but help on debugger
186                     ;; commands refers to "locals", so say both words...
187                     (format t "~&     Local bindings:")
188                     (dolist (loc locals)
189                       (show-pair loc "       "))))
190                (t
191                   (dolist (arg args)
192                     (show-pair arg "   "))
193                   (terpri)
194                   (terpri)
195                   (dolist (loc locals)
196                     (show-pair loc "  "))))))))
197    (error () (format t "#<error printing args and locals>")))
198  (terpri)
199  (terpri))
200
201
202(defun backtrace-call-arguments (context cfp lfun pc)
203  (nconc (let* ((name (function-name lfun)))
204           (if (function-is-current-definition? lfun)
205             (list name)
206             (case *backtrace-format*
207               (:direct
208                  (list (format nil "~s" (or name lfun))))
209               (:list
210                  (list 'funcall (format nil "~s" (or name lfun))))
211               (t (list 'funcall `(function ,(concatenate 'string "#<" (%lfun-name-string lfun) ">")))))))
212         (backtrace-supplied-args context cfp lfun pc)))
213
214(defun backtrace-supplied-args (context frame lfun pc)
215  (multiple-value-bind (args valid) (supplied-argument-list context frame lfun pc)
216    (if (not valid)
217      '("???")   
218      (loop for arg in args
219            collect (if (eq arg (%unbound-marker))
220                      "?"
221                      (let* ((*print-length* *backtrace-print-length*)
222                             (*print-level* *backtrace-print-level*))
223                        (format nil "~s" arg)))))))
224
225;;; Return a list of "interesting" frame addresses in context, most
226;;; recent first.
227(defun %stack-frames-in-context (context &optional (include-internal *backtrace-show-internal-frames*))
228  (collect ((frames))
229    (do* ((p (bt.youngest context) (parent-frame p context))
230          (q (bt.oldest context)))
231         ((eql p q) (frames))
232      (when (or (not (catch-csp-p p context)) include-internal)
233        (when (or (cfp-lfun p) include-internal)
234          (frames p))))))
235
236(defun %map-call-frames-internal (fn context origin count skip-initial test)
237  (when (null skip-initial) (setq skip-initial 0))
238  (when (null count) (setq count target::target-most-positive-fixnum))
239  (unless (eq (last-frame-ptr context origin) (last-frame-ptr context))
240    (error "Origin ~s is not in the stack of ~s" origin context))
241  (let ((q (last-frame-ptr context))
242        (frame-number 0))
243    (do ((p origin (parent-frame p context)))
244        ((or (null p) (eq p q) (%stack< q p context) (<= count 0)) nil)
245      (when (or (null test) (funcall test p context))
246        (when (<= skip-initial frame-number)
247          (funcall fn p context)
248          (decf count))
249        (incf frame-number)))))
250
251(defun %show-stack-frame-label (frame-number p context lfun pc detailed-p)
252  (case *backtrace-format*
253    (:direct
254       (let ((call (backtrace-call-arguments context p lfun pc)))
255         (format t "~&~3D: ~a ~a~@d~:[~; [Exception]~]"
256                 frame-number
257                 (if lfun
258                   (if detailed-p (car call) call)
259                   "<non-function frame>")
260                 "at pc "
261                 pc
262                 (exception-frame-p p))))
263    (t (format t "~&~c(~x) : ~D ~a ~d"
264                      (if (exception-frame-p p)  #\* #\space)
265                      (index->address p) frame-number
266                      (if lfun (backtrace-call-arguments context p lfun pc))
267                      pc))))
268
269
270(defun %access-lisp-data (vstack-index)
271  (%fixnum-ref vstack-index))
272
273(defun %store-lisp-data (vstack-index value)
274  (setf (%fixnum-ref vstack-index) value))
275
276(defun closed-over-value (data)
277  (if (closed-over-value-p data)
278    (uvref data 0)
279    data))
280
281(defun set-closed-over-value (value-cell value)
282  (setf (uvref value-cell 0) value))
283
284
285
286;;; Act as if VSTACK-INDEX points at some lisp data & return that data.
287(defun access-lisp-data (vstack-index)
288  (closed-over-value (%access-lisp-data vstack-index)))
289
290(defun find-local-name (cellno lfun pc)
291  (let* ((n cellno))
292    (when lfun
293      (multiple-value-bind (mask where) (registers-used-by lfun pc)
294        (if (and where (< (1- where) n (+ where (logcount mask))))
295          (let ((j *saved-register-count*))
296            (decf n where)
297            (loop (loop (if (logbitp (decf j) mask) (return)))
298                  (if (< (decf n) 0) (return)))
299            (values (format nil "saved ~a" (aref *saved-register-names* j))
300                    nil))
301          (multiple-value-bind (nreq nopt restp nkeys junk optinitp junk ncells nclosed)
302                               (if lfun (function-args lfun))
303            (declare (ignore junk optinitp))
304            (if nkeys (setq nkeys (+ nkeys nkeys)))
305            (values
306             (if (and ncells (< n ncells))
307               (if (< n nclosed)
308                 :inherited
309                 (if (< (setq n (- n nclosed)) nreq)
310                   "required"
311                   (if (< (setq n (- n nreq)) nopt)
312                     "optional"
313                     (progn
314                       (setq n (- n nopt))
315                       (progn
316                         (if (and nkeys (< n nkeys))
317                           (if (not (logbitp 0 n)) ; a keyword
318                             "keyword"
319                             "key-supplied-p")
320                           (progn
321                             (if nkeys (setq n (- n nkeys)))
322                             (if (and restp (zerop n))
323                               "rest"
324                               "opt-supplied-p")))))))))
325             (match-local-name cellno (function-symbol-map lfun) pc))))))))
326
327(defun map-entry-value (context cfp lfun pc idx unavailable)
328  (declare (fixnum pc idx))
329  (let* ((info (function-symbol-map lfun)))
330    (if (null info)
331      unavailable
332      (let* ((addrs (cdr info))
333             (i (* 3 idx))
334             (addr (uvref addrs i))
335             (startpc (uvref addrs (the fixnum (+ i 1))))
336             (endpc (uvref addrs (the fixnum (+ i 2)))))
337        (declare (fixnum i addr startpc endpc))
338        (if (or (< pc startpc)
339                (>= pc endpc))
340          unavailable
341          (let* ((value (if (= #o77 (ldb (byte 6 0) addr))
342                          (raw-frame-ref cfp context (ash addr (- (+ target::word-shift 6)))
343                                         unavailable)
344                          (find-register-argument-value context cfp addr unavailable))))
345            (if (typep value 'value-cell)
346              (uvref value 0)
347              value)))))))
348
349;;; Returns non-nil on success (not newval)
350(defun set-map-entry-value (context cfp lfun pc idx newval)
351  (declare (fixnum pc idx))
352  (let* ((unavailable (cons nil nil))
353         (value (map-entry-value context cfp lfun pc idx unavailable)))
354    (if (eq value unavailable)
355      nil
356      (if (typep value 'value-cell)
357        (progn (setf (uvref value 0) newval) t)
358
359        (let* ((addrs (cdr (function-symbol-map lfun)))
360               (addr (uvref addrs (the fixnum (* 3 idx)))))
361          (declare (fixnum  addr))
362          (if (= #o77 (ldb (byte 6 0) addr))
363            (raw-frame-set cfp context (ash addr (- (+ target::word-shift 6))) newval)
364            (set-register-argument-value context cfp addr newval))
365          t)))))
366
367         
368(defun argument-value (context cfp lfun pc name &optional (quote t))
369  (declare (fixnum pc))
370  (let* ((info (function-symbol-map lfun))
371         (unavailable (%unbound-marker)))
372    (if (null info)
373      unavailable
374      (let* ((names (car info))
375             (addrs (cdr info)))
376        (do* ((nname (1- (length names)) (1- nname))
377              (naddr (- (length addrs) 3) (- naddr 3)))
378             ((or (< nname 0) (< naddr 0)) unavailable)
379          (declare (fixnum nname naddr))
380          (when (eq (svref names nname) name)
381            (let* ((value
382                    (let* ((addr (uvref addrs naddr))
383                           (startpc (uvref addrs (the fixnum (1+ naddr))))
384                           (endpc (uvref addrs (the fixnum (+ naddr 2)))))
385                      (declare (fixnum addr startpc endpc))
386                      (if (or (< pc startpc)
387                              (>= pc endpc))
388                        unavailable
389                        (if (= #o77 (ldb (byte 6 0) addr))
390                          (raw-frame-ref cfp context (ash addr (- (+ target::word-shift 6)))
391                                         unavailable)
392                          (find-register-argument-value context cfp addr unavailable))))))
393              (if (typep value 'value-cell)
394                (setq value (uvref value 0)))
395              (if (or (not quote) (self-evaluating-p value))
396                (return value)
397                (return (list 'quote value))))))))))
398
399
400
401(defun raw-frame-ref (cfp context index bad)
402  (%raw-frame-ref cfp context index bad))
403
404(defun raw-frame-set (cfp context index new)
405  (%raw-frame-set cfp context index new))
406 
407(defun find-register-argument-value (context cfp regval bad)
408  (%find-register-argument-value context cfp regval bad))
409
410(defun set-register-argument-value (context cfp regval newval)
411  (%set-register-argument-value context cfp regval newval))
412
413   
414
415(defun dbg-form (frame-number)
416  (when *break-frame*
417    (let* ((cfp (nth-raw-frame frame-number *break-frame* nil)))
418      (if (and cfp (not (catch-csp-p cfp nil)))
419        (multiple-value-bind (function pc)
420            (cfp-lfun cfp)
421          (if (and function
422                   (function-is-current-definition? function))
423            (block %cfp-form
424              (collect ((form))
425                (multiple-value-bind (nreq nopt restp keys allow-other-keys
426                                           optinit lexprp ncells nclosed)
427                    (function-args function)
428                  (declare (ignore ncells))
429                  (unless (or lexprp restp (> 0 nclosed) (> 0 nopt) keys allow-other-keys
430                              optinit)
431                    (let* ((name (function-name function)))
432                      (multiple-value-bind (arglist win)
433                          (arglist-from-map function)
434                      (when (and win name (symbolp name))
435                        (form name)
436                        (dotimes (i nreq)
437                          (let* ((val (argument-value nil cfp function pc (pop arglist))))
438                            (if (closed-over-value-p val)
439                              (setq val (%svref val target::value-cell.value-cell)))
440                            (if (eq val (%unbound-marker))
441                              (return-from %cfp-form nil))
442                            (form val))))))))
443                (form)))))))))
444
445(defun function-args (lfun)
446  "Returns 9 values, as follows:
447     req = number of required arguments
448     opt = number of optional arguments
449     restp = t if rest arg
450     keys = number of keyword arguments or NIL if &key not mentioned
451     allow-other-keys = t if &allow-other-keys present
452     optinit = t if any optional arg has non-nil default value or supplied-p
453               variable
454     lexprp = t if function is a lexpr, in which case all other values are
455              undefined.
456     ncells = number of stack frame cells used by all arguments.
457     nclosed = number of inherited values (now counted distinctly from required)
458     All numeric values (but ncells) are mod 64."
459  (let* ((bits (lfun-bits lfun))
460         (req (ldb $lfbits-numreq bits))
461         (opt (ldb $lfbits-numopt bits))
462         (restp (logbitp $lfbits-rest-bit bits))
463         (keyvect (lfun-keyvect lfun))
464         (keys (and keyvect (length keyvect)))
465         (allow-other-keys (logbitp $lfbits-aok-bit bits))
466         (optinit (logbitp $lfbits-optinit-bit bits))
467         (lexprp (logbitp $lfbits-restv-bit bits))
468         (nclosed (ldb $lfbits-numinh bits)))
469    (values req opt restp keys allow-other-keys optinit lexprp
470            (unless (or lexprp)
471              (+ req opt (if restp 1 0) (if keys (+ keys keys) 0)
472                 (if optinit opt 0) nclosed))
473            nclosed)))
474
475;;; If we can tell reliably, return the function's minimum number of
476;;; non-inherited arguments, the maximum number of such arguments (or NIL),
477;;; and the actual number of such arguments.  We "can't tell" if either
478;;; of the arguments to this function are null, and we can't tell reliably
479;;; if any of the lfbits fields are full.
480(defun min-max-actual-args (fn nargs)
481  (let* ((lfbits (if (and fn nargs)
482                   (lfun-bits fn)
483                   -1))
484         (raw-req (ldb $lfbits-numreq lfbits))
485         (raw-opt (ldb $lfbits-numopt lfbits))
486         (raw-inh (ldb $lfbits-numinh lfbits)))
487    (declare (fixnum raw-req raw-opt raw-inh))
488    (if (or (eql raw-req (1- (ash 1 (byte-size $lfbits-numreq))))
489            (eql raw-opt (1- (ash 1 (byte-size $lfbits-numopt))))
490            (eql raw-inh (1- (ash 1 (byte-size $lfbits-numinh)))))
491      (values nil nil nil)
492      (values raw-req
493              (unless (or (lfun-keyvect fn)
494                          (logbitp $lfbits-rest-bit lfbits)
495                          (logbitp $lfbits-restv-bit lfbits))
496                (+ raw-req raw-opt))
497              (- nargs raw-inh)))))
498
499
500
501(defun closed-over-value-p (value)
502  (eql target::subtag-value-cell (typecode value)))
503
504
505(defun variables-in-scope (lfun pc)
506  ;; Return a list of all symbol names "in scope" in the function lfun
507  ;; at relative program counter PC, using the function's symbol map.
508  ;; The list will be ordered so that least-recent bindings appear first.
509  ;; Return a list of the matching symbol map entries as a second value
510  (when pc
511    (locally (declare (fixnum pc))
512      (let* ((map (function-symbol-map lfun))
513             (names (car map))
514             (info (cdr map)))
515        (when map
516          (let* ((vars ())
517                 (indices ()))
518            (dotimes (i (length names) (values vars indices))
519              (let* ((start-pc (aref info (1+ (* 3 i))))
520                     (end-pc (aref info (+ 2 (* 3 i)))))
521                (declare (fixnum start-pc end-pc))
522                (when (and (>= pc start-pc)
523                           (< pc end-pc))
524                  (push i indices)
525                  (push (svref names i) vars))))))))))
526
527
528(defun arg-value (context cfp lfun pc unavailable name)
529  (multiple-value-bind (vars map-indices) (variables-in-scope lfun pc)
530    (multiple-value-bind (valid req opt rest keys)
531        (arg-names-from-map lfun pc)
532      (if valid
533        (let* ((nargs (+ (length req) (length opt) (if rest 1 0) (length keys)))
534               (pos (position name vars)))
535          (if (and pos (< pos nargs))
536            (map-entry-value context cfp lfun pc (nth pos map-indices) unavailable)
537            unavailable))
538        unavailable))))
539
540(defun local-value (context cfp lfun pc unavailable name)
541  (multiple-value-bind (vars map-indices) (variables-in-scope lfun pc)
542    (multiple-value-bind (valid req opt rest keys)
543        (arg-names-from-map lfun pc)
544      (if valid
545        (let* ((nargs (+ (length req) (length opt) (if rest 1 0) (length keys)))
546               (names (nthcdr nargs vars))
547               (indices (nthcdr nargs map-indices))
548               (pos (if (typep name 'unsigned-byte)
549                      name
550                      (position name names :from-end t))))
551          (if pos
552            (map-entry-value context cfp lfun pc (nth pos indices) unavailable)
553            unavailable))
554        unavailable))))
555
556(defun set-arg-value (context cfp lfun pc name new)
557  (multiple-value-bind (vars map-indices) (variables-in-scope lfun pc)
558    (multiple-value-bind (valid req opt rest keys)
559        (arg-names-from-map lfun pc)
560      (if valid
561        (let* ((nargs (+ (length req) (length opt) (if rest 1 0) (length keys)))
562               (pos (position name vars)))
563          (when (and pos (< pos nargs))
564            (set-map-entry-value context cfp lfun pc (nth pos map-indices) new)))))))
565
566(defun set-local-value (context cfp lfun pc name new)
567  (multiple-value-bind (vars map-indices) (variables-in-scope lfun pc)
568    (multiple-value-bind (valid req opt rest keys)
569        (arg-names-from-map lfun pc)
570      (if valid
571        (let* ((nargs (+ (length req) (length opt) (if rest 1 0) (length keys)))
572               (names (nthcdr nargs vars))
573               (indices (nthcdr nargs map-indices))
574               (pos (if (typep name 'unsigned-byte)
575                      name
576                      (position name names :from-end t))))
577          (if (and pos (< pos nargs))
578            (set-map-entry-value context cfp lfun pc (nth pos indices) new)))))))
579
580
581(defun arguments-and-locals (context cfp lfun pc &optional unavailable)
582  (multiple-value-bind (vars map-indices) (variables-in-scope lfun pc)
583    (collect ((args)
584              (inherited-indices)
585              (inherited-vars)
586              (locals))
587      (multiple-value-bind (valid req opt rest keys)
588          (arg-names-from-map lfun pc)
589        (when valid
590          (let* ((numinh (ldb $lfbits-numinh (lfun-bits lfun))))
591            (dotimes (i numinh)
592              (inherited-indices (pop map-indices))
593              (inherited-vars (pop vars))))
594          (let* ((nargs (+ (length req) (length opt) (if rest 1 0) (length keys)))
595                 (nlocals (- (length vars) nargs))
596                 (local-vars (append (nthcdr nargs vars) (inherited-vars)))
597                 (local-indices (append (nthcdr nargs map-indices) (inherited-indices)))
598                 (arg-vars (if (<= nlocals 0) vars (nbutlast vars nlocals)))
599                 (arg-indices (if (<= nlocals 0) map-indices (nbutlast map-indices nlocals))))
600            (flet ((get-arg-value (name)
601                     (let* ((pos (position name arg-vars :test #'eq)))
602                       (when pos
603                         (args (cons name (map-entry-value context cfp lfun pc (nth pos arg-indices) unavailable))))))
604                   (get-local-value (name)
605                     (when name
606                       (locals (cons name (map-entry-value context cfp lfun pc (pop local-indices) unavailable))))))
607              (dolist (name req)
608                (get-arg-value name))
609              (dolist (name opt)
610                (get-arg-value name))
611              (when rest
612                (get-arg-value rest))
613              (dolist (name keys)
614                (get-arg-value name))
615              (dolist (name local-vars)
616                (get-local-value name)))))
617           (values (args) (locals))))))
618
619;; Return list of supplied arguments, as best we can reconstruct it.
620(defun supplied-argument-list (context frame lfun pc)
621  (if (null pc)
622    (values nil nil)
623    (if (<= pc target::arg-check-trap-pc-limit)
624      (values (arg-check-call-arguments frame lfun) t)
625      (multiple-value-bind (params valid) (arglist-from-map lfun)
626        (if (not valid)
627          (values nil nil)
628          (let* ((args (arguments-and-locals context frame lfun pc)) ;overkill, but will do.
629                 (state :required)
630                 (result ()))
631            (dolist (param params)
632              (if (or (member param lambda-list-keywords) (eq param '&lexpr))
633                (setq state param)
634                (let* ((pair (pop args))
635                       (value (cdr pair)))
636                  (case state
637                    (&lexpr
638                     (with-list-from-lexpr (rest value)
639                       (dolist (r rest) (push r result)))
640                     (return))
641                    (&rest
642                     (dolist (r value) (push r result))
643                     (return))
644                    (&key (push param result)))
645                  (push value result))))
646            (values (nreverse result) t)))))))
647
648
649(defun safe-cell-value (val)
650  val)
651
652(defun closure-closed-over-values (closure)
653  (when (typep closure 'compiled-lexical-closure)
654    (let* ((inner (closure-function closure))
655           (nclosed (nth-value 8 (function-args inner)))
656           (names (car (function-symbol-map inner))))
657      (when nclosed
658        (collect ((cells))
659          (do* ((i (1- (length names)) (1- i))
660                (k 0 (1+ k))
661                (idx 2 (1+ idx)))
662               ((= k nclosed) (reverse (cells)))
663            (let* ((name (svref names i))
664                   (imm (nth-immediate closure idx)))
665              (cells (list name (if (closed-over-value-p imm)
666                                  (closed-over-value imm)
667                                  imm))))))))))
668
669     
670;;; Find the oldest binding frame that binds the same symbol as
671;;; FRAME in context.  If found, return the saved value of that
672;;; binding, else the value of the symbol in the context's thread.
673(defun oldest-binding-frame-value (context frame)
674  (let* ((oldest nil)
675         (binding-index (%fixnum-ref frame (ash 1 target::fixnum-shift))))
676    (do* ((db (db-link context) (%fixnum-ref db 0)))
677         ((eq frame db)
678          (if oldest
679            (%fixnum-ref oldest (ash 2 target::fixnum-shift))
680            (let* ((symbol (binding-index-symbol binding-index)))
681              (if context
682                (symbol-value-in-tcr symbol (bt.tcr context))
683                (%sym-value symbol)))))
684      (if (eq (%fixnum-ref db (ash 1 target::fixnum-shift)) binding-index)
685        (setq oldest db)))))
686
687(defun (setf oldest-binding-frame-value) (new context frame)
688  (let* ((oldest nil)
689         (binding-index (%fixnum-ref frame (ash 1 target::fixnum-shift))))
690    (do* ((db (db-link context) (%fixnum-ref db 0)))
691         ((eq frame db)
692          (if oldest
693            (setf (%fixnum-ref oldest (ash 2 target::fixnum-shift)) new)
694            (let* ((symbol (binding-index-symbol binding-index)))
695              (if context
696                (setf (symbol-value-in-tcr symbol (bt.tcr context)) new)
697                (%set-sym-value symbol new)))))
698      (if (eq (%fixnum-ref db (ash 1 target::fixnum-shift)) binding-index)
699        (setq oldest db)))))
700   
701
702
703;;; End of backtrace.lisp
Note: See TracBrowser for help on using the repository browser.