Custom Query (1030 matches)

This code:

(defun matrix-times-matrix (mat1 mat2)
  "Multiplies two matrices together"
  (if (= (array-dimension mat1 1)
         (array-dimension mat2 0))
      (let ((result (make-array (list (array-dimension mat1 0)
                                      (array-dimension mat2 1)))))
        (dotimes (row (array-dimension result 0))
          (dotimes (column (array-dimension result 1))
            (let ((terms 0))
              (dotimes (middle (array-dimension mat1 1))
                (setf terms (+ terms (* (or (aref mat1 row middle) 0)
                                        (or (aref mat2 middle column) 0)))))
              (setf (aref result row column) terms))))
        (return-from matrix-times-matrix result))
      (progn
        (format t "~&Illegal matrix multiplication:
Matrix sizes ~a x ~a and ~a x ~a don't match."
                (array-dimension mat1 0)
                (array-dimension mat1 1)
                (array-dimension mat2 0)
                (array-dimension mat2 1))
        (return-from matrix-times-matrix nil))))

blows up in the compiler, when it discovers that it has to go through the write barrier at .SPgvset and that things are in the wrong registers for that.

It is possible that this just got exposed in 040708, because previous versions may have gotten MAKE-ARRAY type inferencing wrong

If a compare-and-swap (cmpxchgq) instruction used in the subprimitive _SPstore_node_conditional failed (cleard the z flag), the subsequent branch instruction branched forward to local label 0. It should have branched backward, retrying the store-conditional.

Branching backward typically caused code in _SPprogvsave - which checks to ensure that a list of values was a proper list - to signal a confusing, spurious error.

Apple has decided that renaming some structures dealing with thread contexts and the fields in those structures would help to ensure compatibility with some C standard or other; the names of these fields therefore depend on what header files one looks at (and what -preserve-broken-legacy-behavior options are in effect.)

Lisp code occasionally needs to poke around in these structures, and therefore defines its own set of record types with its own field names "manually".

The manual definition of :darwin-ppc-thread-state64 in ccl/level-1/ppc-trap-support.lisp has been wrong; the structure is defined with #pragma pack(4) in effect, so some 64-bit fields that should be misaligned are actually (and incorrectly) naturally aligned.

One consequence of this is that backtrace doesn't work on darwinppc64 in some contexts, e.g., after a keyboard interrupt. There may be other consequences, as well.