Simpler and more precise type derivation for APPEND/NCONC

[sbcl.git] / src / compiler / mips / call.lisp

diff --git a/src/compiler/mips/call.lisp b/src/compiler/mips/call.lisp
index 5e47120..b10e80e 100644 (file)
--- a/src/compiler/mips/call.lisp
+++ b/src/compiler/mips/call.lisp
@@ -128,6 +128,23 @@
       (when nfp
         (inst addu val nfp (bytes-needed-for-non-descriptor-stack-frame))))))
 
+;;; Accessing a slot from an earlier stack frame is definite hackery.
+(define-vop (ancestor-frame-ref)
+  (:args (frame-pointer :scs (descriptor-reg))
+         (variable-home-tn :load-if nil))
+  (:results (value :scs (descriptor-reg any-reg)))
+  (:policy :fast-safe)
+  (:generator 4
+    (aver (sc-is variable-home-tn control-stack))
+    (loadw value frame-pointer (tn-offset variable-home-tn))))
+(define-vop (ancestor-frame-set)
+  (:args (frame-pointer :scs (descriptor-reg))
+         (value :scs (descriptor-reg any-reg)))
+  (:results (variable-home-tn :load-if nil))
+  (:policy :fast-safe)
+  (:generator 4
+    (aver (sc-is variable-home-tn control-stack))
+    (storew value frame-pointer (tn-offset variable-home-tn))))
 
 (define-vop (xep-allocate-frame)
   (:info start-lab copy-more-arg-follows)
@@ -405,6 +422,15 @@ default-value-8
               nvals)
   (:temporary (:scs (non-descriptor-reg)) temp))
 
+\f
+;;; This hook in the codegen pass lets us insert code before fall-thru entry
+;;; points, local-call entry points, and tail-call entry points.  The default
+;;; does nothing.
+(defun emit-block-header (start-label trampoline-label fall-thru-p alignp)
+  (declare (ignore fall-thru-p alignp))
+  (when trampoline-label
+    (emit-label trampoline-label))
+  (emit-label start-label))
 
 \f
 ;;;; Local call with unknown values convention return:
@@ -783,12 +809,7 @@ default-value-8
                 (insert-step-instrumenting (callable-tn)
                   ;; Conditionally insert a conditional trap:
                   (when step-instrumenting
-                    ;; Get the symbol-value of SB!IMPL::*STEPPING*
-                    (inst lw stepping null-tn
-                          (- (+ symbol-value-slot
-                                (truncate (static-symbol-offset 'sb!impl::*stepping*)
-                                          n-word-bytes))
-                             other-pointer-lowtag))
+                    (load-symbol-value stepping sb!impl::*stepping*)
                     ;; If it's not NIL, trap.
                     (inst beq stepping null-tn step-done-label)
                     (inst nop)
@@ -1171,7 +1192,7 @@ default-value-8
       (move context context-arg)
       (move count count-arg)
       ;; Check to see if there are any arguments.
-      (inst beq count zero-tn done)
+      (inst beq count done)
       (move result null-tn t)
 
       ;; We need to do this atomically.
@@ -1199,7 +1220,7 @@ default-value-8
 
         ;; Dec count, and if != zero, go back for more.
         (inst addu count count (fixnumize -1))
-        (inst bne count zero-tn loop)
+        (inst bne count loop)
 
         ;; Store the value in the car (in delay slot)
         (storew temp dst 0 list-pointer-lowtag)
@@ -1248,7 +1269,7 @@ default-value-8
     (let ((err-lab
            (generate-error-code vop invalid-arg-count-error nargs)))
       (cond ((zerop count)
-             (inst bne nargs zero-tn err-lab)
+             (inst bne nargs err-lab)
              (inst nop))
             (t
              (inst li temp (fixnumize count))
@@ -1288,12 +1309,7 @@ default-value-8
   (:policy :fast-safe)
   (:vop-var vop)
   (:generator 3
-    ;; Get the symbol-value of SB!IMPL::*STEPPING*
-    (inst lw stepping null-tn
-          (- (+ symbol-value-slot
-                (truncate (static-symbol-offset 'sb!impl::*stepping*)
-                          n-word-bytes))
-             other-pointer-lowtag))
+    (load-symbol-value stepping sb!impl::*stepping*)
     ;; If it's not NIL, trap.
     (inst beq stepping null-tn DONE)
     (inst nop)