Changeset 13014

Timestamp:

Oct 13, 2009, 9:08:44 PM (15 years ago)

Author:

R. Matthew Emerson

Message:

Add an "emulate" restart for a write-to-watched-object condition.

This operates at a very low level: it emulates the machine instruction
that caused the write.

In order to do this, we suspend other threads and suspend the gc so
that we can use the register state in the exception context to
compute an effective address and perform the store.

The code only knows how to emulate storing a GPR to memory; the
restart will not be offered if the faulting instruction is some other
kind of operation.

File:

• trunk/source/level-1/x86-trap-support.lisp (modified) (1 diff)

trunk/source/level-1/x86-trap-support.lisp

@@ -445 +445 @@
                                          :instruction insn)
                                         nil frame-ptr)
+                    #-windows-target
+                    (emulate ()
+                      :test (lambda (c)
+                              (declare (ignore c))
+                              (x86-can-emulate-instruction insn))
+                      :report
+                      "Emulate this instruction, leaving the object watched."
+                      (flet ((watchedp (object)
+                               (%map-areas #'(lambda (x)
+                                               (when (eq object x)
+                                                 (return-from watchedp t)))
+                                           area-watched area-watched)))
+                        (let ((result nil))
+                          (with-other-threads-suspended
+                            (when (watchedp object)
+                              ;; We now trust that the object is in a
+                              ;; static gc area.
+                              (let* ((a (+ (%address-of object) offset))
+                                     (ptr (%int-to-ptr
+                                           (logandc2 a (1- *host-page-size*)))))
+                                (#_mprotect ptr *host-page-size* #$PROT_WRITE)
+                                (setq result (x86-emulate-instruction xp insn))
+                                (#_mprotect ptr *host-page-size*
+                                            (logior #$PROT_READ #$PROT_EXEC)))))
+                          (if result
+                            (setq skip insn-length)
+                            (error "could not emulate the instrution")))))
                     (skip ()
                       :test (lambda (c)