Argthtjtr

Are there any tools in Common Lisp that can be used to debug a condition along the following lines?

There is a hashtable that gets modified (one of key's values turns to NIL), and I am trying to debug it. I was able to narrow it down to where it is supposedly happening, but the table does not explicitly get modified there via the official accessors.

I can't post code because it is proprietary.

I would suggest two things. The first is to try to trace the function that modifies hash tables. That is (setf gethash) except that gethash is an accessor and not a function. To find out which function is used by the implementation to update the hash-table, do e.g.

(disassemble (compile (defun foo (x y) (setf (gethash x y) t))))

which shows assembly code that should contain a call to an internal function with a name like puthash.

The act of (trace puthash) might lead to a problem as the implementation might update a hash-table as part of this call. But assuming it works, it might show you where an unexpected hash-table update takes place.

Some implementations have extended the functionality of trace. For example Allegro CL offer many trace options. E.g. if your functions are called foo and bar and you want to see calls to excl::%puthash from within those functions, you'd say:

(trace (excl::%puthash :inside (foo bar))

and if you want to see what the context of the call is, include a bit of the stack:

cl-user(1): (trace (excl::%puthash :inside foo :show-stack 3))

(excl::%puthash)

cl-user(2): (setf (gethash 3 (make-hash-table)) 2)

;; Note: no trace output, because not in foo

2

cl-user(3): (foo 3 (make-hash-table))

;; Note: within foo, so trace output which includes 3 stack frames

 0[2]: (excl::%puthash 3 #<eql hash-table with 0 entries @ #x100192cfa72> t)

 0^      <- (system::..runtime-operation "fwrap_start" 3 #<eql hash-table with 0 entries @ #x100192cfa72> t)

 0^      <- (foo 3 #<eql hash-table with 0 entries @ #x100192cfa72>)

 0^      <- (eval (foo 3 (make-hash-table)))

 0[2]: returned t

t

Tracing like this can be extremely helpful when dealing with unknown code.

The second thing to do, is checking the code to make sure that keys stored in the hash-table are not modified. E.g.

(let ((x (list 1 2))

      (ht (make-hash-table :test 'equal))

   (setf (gethash x ht) t)

   (setf (car x) 10) ;; not allowed!

   (gethash x ht)) ;; now in a funny state: may return T, or nil

See 18.1.2 Modifying Hash Table Keys.
Moreover literal objects may not be modified either, that could be a cause of weirdness too:

(let ((x '(1 2)))

   (setf (car x) 10) ;; not allowed!