Paste number 91584: Minimal test cases for xc problems are nice.

Index of paste annotations: 1 | 2 | 3

Paste number 91584: Minimal test cases for xc problems are nice.
Pasted by: nyef
When:9 months, 1 day ago
Share:Tweet this! | http://paste.lisp.org/+1YO0
Channel:#lisp
Paste contents:
Raw Source | XML | Display As 
;;;
;;; xc-tests/test1.lisp
;;;

(in-package "SB!IMPL")

(defun no-arg-test ()
  (%primitive print "in no-arg-test"))

(defun !cold-init ()
  (%primitive print "initial function start")
  (no-arg-test)
  (rest-key-args-test :foo :bar :baz :quux)
  (%primitive sb!c:halt))

(defun rest-key-args-test (&rest initargs
			   &key (args nil argsp)
			   &allow-other-keys)
  (if argsp
      args
      (apply #'rest-key-args-test-2 initargs)))

(defun rest-key-args-test-2 (a1 a2 a3 a4)
  (when (eq a1 :foo)
    (%primitive print "rkat2: foo is right"))
  (when (eq a2 :bar)
    (%primitive print "rkat2: foo is right"))
  (when (eq a3 :baz)
    (%primitive print "rkat2: foo is right"))
  (when (eq a4 :quux)
    (%primitive print "rkat2: foo is right")))

;;; EOF

Annotations for this paste:

Annotation number 1: output received
Pasted by: nyef
When:9 months, 1 day ago
Share:Tweet this! | http://paste.lisp.org/+1YO0/1
Paste contents:
Raw Source | Display As 
initial function start
in no-arg-test
internal error too early in init, can't recover


internal error #24 (invalid argument count)
    SC: 20, Offset: 2		  0x00000020: even fixnum: 8

Annotation number 2: The disassembly, which probably won't show the bug
Pasted by: nyef
When:9 months, 1 day ago
Share:Tweet this! | http://paste.lisp.org/+1YO0/2
Paste contents:
Raw Source | Display As 
assembly code for #<SB!C:COMPONENT
                    :NAME (SB!C::VARARGS-ENTRY REST-KEY-ARGS-TEST)
                    :ID 7323886 {1005761501}>

in the ELSEWHERE segment:
L6:
in the REGULAR segment:
L7:
in the ELSEWHERE segment:
L8:
in the REGULAR segment:

VOP XEP-ALLOCATE-FRAME {# T} 
        .align  4
L9:
L1:
        SIMPLE-FUN-HEADER-WORD
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        BYTE    0
        POP     QWORD PTR [RBP+8]
L10:

VOP COPY-MORE-ARG {0} 
        JRCXZ   L11
        LEA     #<TN t36[RBX]>, QWORD PTR [RBP-48]
        SHL     #<TN t37[RCX]>, 2
        SUB     #<TN t36[RBX]>, #<TN t37[RCX]>
        SHR     #<TN t37[RCX]>, 2
        MOV     #<TN t38[RSP]>, #<TN t36[RBX]>
        MOV     #<TN t36[RBX]>, #<TN t37[RCX]>
        SUB     #<TN t37[RCX]>, 6
        JMP     BE, L12
        LEA     #<TN t39[R9]>, QWORD PTR [RBP+16]
        SHL     #<TN t36[RBX]>, 2
        SUB     #<TN t39[R9]>, #<TN t36[RBX]>
        SHR     #<TN t36[RBX]>, 2
        XOR     #<TN t40[R8]>, #<TN t40[R8]>
L13:
        MOV     #<TN t41[R10]>, QWORD PTR [R9+R8+0]
        MOV     QWORD PTR [RSP+R8+0], #<TN t41[R10]>
        ADD     #<TN t40[R8]>, 8
        SUB     #<TN t37[RCX]>, 2
        JMP     NZ, L13
L12:
        MOV     #<TN t37[RCX]>, #<TN t36[RBX]>
        MOV     QWORD PTR [RBP-56], #<TN t42[RDX]>
        CMP     #<TN t37[RCX]>, 2
        JMP     EQ, L14
        MOV     QWORD PTR [RBP-64], #<TN t43[RDI]>
        CMP     #<TN t37[RCX]>, 4
        JMP     EQ, L14
        MOV     QWORD PTR [RBP-72], #<TN t44[RSI]>
        JMP     L14
L11:
        LEA     #<TN t38[RSP]>, QWORD PTR [RBP-48]
L14:

VOP MOVE t1[RCX] => #:G222961!2[R10] 
        MOV     #<TN #:G222961!2[R10]>, #<TN t1[RCX]>

VOP NOTE-ENVIRONMENT-START {#} 
L15:

VOP MORE-ARG-CONTEXT #:G222961!2[R10] {0} => t11[RBX] t12[RDX] 
        MOV     #<TN t12[RDX]>, #<TN #:G222961!2[R10]>
        LEA     #<TN t11[RBX]>, QWORD PTR [RSP+RDX*4-8]

VOP MOVE t12[RDX] => #:N-COUNT-4!14[R9] 
        MOV     #<TN #:N-COUNT-4!14[R9]>, #<TN t12[RDX]>

VOP FAST---C/FIXNUM=>FIXNUM t12[RDX] {1} => t15[RCX] 
        MOV     #<TN t15[RCX]>, #<TN t12[RDX]>
        SUB     #<TN t15[RCX]>, 2

VOP FAST-NEGATE/FIXNUM t15[RCX] => t16[RCX] 
        NEG     #<TN t16[RCX]>

VOP MOVE 'NIL!18 => #:N-SUPPLIED-222956!19[RDI] 
        MOV     #<TN #:N-SUPPLIED-222956!19[RDI]>, 537919511

VOP MOVE 'NIL!18 => #:N-VALUE-222955!20[R8] 
        MOV     #<TN #:N-VALUE-222955!20[R8]>, 537919511

VOP FAST-LOGAND-C/FIXNUM=>FIXNUM t12[RDX] {1} => t21[RDX] 
        AND     #<TN t21[RDX]>, 2

VOP FAST-EQL-C/FIXNUM t21[RDX] {0} 
        TEST    #<TN t21[RDX]>, #<TN t21[RDX]>

VOP BRANCH-IF {# # T} 
        JMP     NE, L5

L16:
L17:

VOP BRANCH {#} 
        JMP     L3

        .align  4
L2:

VOP MORE-KW-ARG #:N-CONTEXT-3!13[RBX] #:N-INDEX-222950!17[RCX]
                => t22[RDX] t23[RSI] 
        MOV     #<TN t22[RDX]>, QWORD PTR [RBX+RCX*4+0]
        MOV     #<TN t23[RSI]>, QWORD PTR [RBX+RCX*4+8]

VOP FAST-+-C/FIXNUM=>FIXNUM #:N-INDEX-222950!17[RCX] {2} => t24[RCX] 
        ADD     #<TN t24[RCX]>, 4

VOP IF-EQ t23[RSI] ':ARGS!25[Const6]>t26[R13] 
        CMP     #<TN t23[RSI]>, #<TN ':ARGS!25[Const6]>

VOP BRANCH-IF {# # T} 
        JMP     NE, L3

L18:

VOP MOVE 'T!27 => #:N-SUPPLIED-222956!19[RDI] 
        MOV     #<TN #:N-SUPPLIED-222956!19[RDI]>, 537919567

VOP MOVE t22[RDX] => #:N-VALUE-222955!20[R8] 
        MOV     #<TN #:N-VALUE-222955!20[R8]>, #<TN t22[RDX]>

L3:

VOP FAST-IF->-C/FIXNUM #:N-INDEX-222950!17[RCX] {0} 
        CMP     #<TN #:N-INDEX-222950!17[RCX]>, 0

VOP BRANCH-IF {# # T} 
        JMP     LE, L2

L19:

VOP LISTIFY-REST-ARGS #:N-CONTEXT-3!13[RBX] #:N-COUNT-4!14[R9] => t28[RBX] 
        MOV     #<TN t45[RSI]>, #<TN #:N-CONTEXT-3!13[RBX]>
        MOV     #<TN t46[RCX]>, #<TN #:N-COUNT-4!14[R9]>
        MOV     #<TN t28[RBX]>, 537919511
        JRCXZ   L20
        LEA     #<TN t47[RDX]>, QWORD PTR [RCX*8+0]
        MOV     QWORD PTR [+537921576], #<TN t48[RBP]>
        MOV     #<TN t49[R11]>, QWORD PTR [+#S(SB!C:FIXUP
                                               :NAME boxed_region
                                               :FLAVOR FOREIGN
                                               :OFFSET NIL)]
        ADD     #<TN t47[RDX]>, #<TN t49[R11]>
        CMP     QWORD PTR [+#S(SB!C:FIXUP
                               :NAME boxed_region
                               :FLAVOR FOREIGN
                               :OFFSET 8)], #<TN t47[RDX]>
        JMP     BE, L21
        MOV     QWORD PTR [+#S(SB!C:FIXUP
                               :NAME boxed_region
                               :FLAVOR FOREIGN
                               :OFFSET NIL)], #<TN t47[RDX]>
        LEA     #<TN t47[RDX]>, BYTE PTR [R11+7]
L22:
in the ELSEWHERE segment:
L21:
        SUB     #<TN t47[RDX]>, QWORD PTR [+#S(SB!C:FIXUP
                                               :NAME boxed_region
                                               :FLAVOR FOREIGN
                                               :OFFSET NIL)]
        PUSH    #<TN t47[RDX]>
        LEA     #<TN t49[R11]>, QWORD PTR [+#S(SB!C:FIXUP
                                               :NAME alloc_tramp
                                               :FLAVOR FOREIGN
                                               :OFFSET NIL)]
        CALL    #<TN t49[R11]>
        POP     #<TN t47[RDX]>
        LEA     #<TN t47[RDX]>, BYTE PTR [RDX+7]
        JMP     L22
in the REGULAR segment:
        STD
        MOV     #<TN t28[RBX]>, #<TN t47[RDX]>
        JMP     L23
L24:
        ADD     #<TN t47[RDX]>, 16
        MOV     QWORD PTR [RDX-15], #<TN t47[RDX]>
L23:
        LODS    #<TN t50[RAX]>
        MOV     QWORD PTR [RDX-7], #<TN t50[RAX]>
        SUB     #<TN t46[RCX]>, 2
        JMP     NZ, L24
        MOV     QWORD PTR [RDX+1], 537919511
        CLD
        XOR     QWORD PTR [+537921576], #<TN t48[RBP]>
        JMP     Z, L25
        BREAK   9
L25:
L20:

VOP MOVE t28[RBX] => INITARGS!29[RCX] 
        MOV     #<TN INITARGS!29[RCX]>, #<TN t28[RBX]>

L26:

VOP IF-EQ #:N-SUPPLIED-222956!19[RDI] 'NIL!18 
        CMP     #<TN #:N-SUPPLIED-222956!19[RDI]>, 537919511

VOP BRANCH-IF {# # NIL} 
        JMP     E, L4

L27:
L28:

VOP MOVE #:N-VALUE-222955!20[R8] => t30[RDX] 
        MOV     #<TN t30[RDX]>, #<TN #:N-VALUE-222955!20[R8]>

VOP RETURN-SINGLE t5[S1] t9[S0] t30[RDX] 
L29:
        MOV     #<TN t38[RSP]>, #<TN t48[RBP]>
        CLC
        POP     #<TN t48[RBP]>
        RET

L4:

VOP SAFE-FDEFN-FUN t31[Const7]>t32[RAX] => t33[RBX] 
        MOV     #<TN t32[RAX]>, #<TN t31[Const7]>
        MOV     #<TN t33[RBX]>, QWORD PTR [RAX+1]
        CMP     #<TN t33[RBX]>, 537919511
in the ELSEWHERE segment:
L30:
        INT     3
L31:
        BYTE    10
        BYTE    2
        BYTE    23
        BYTE    21
in the REGULAR segment:
        JMP     E, L30

VOP VALUES-LIST INITARGS!29[RCX] => t34[RSI] t35[RAX] 
        MOV     #<TN t34[RSI]>, #<TN t38[RSP]>
        MOV     #<TN t51[RDX]>, 537919511
L32:
        CMP     #<TN t52[RCX]>, #<TN t51[RDX]>
        JMP     E, L33
        PUSH    QWORD PTR [RCX-7]
        MOV     #<TN t52[RCX]>, QWORD PTR [RCX+1]
        MOV     #<TN t53[RAX]>, #<TN t52[RCX]>
        AND     #<TN t54[AL]>, 15
        CMP     #<TN t54[AL]>, 7
        JMP     E, L32
        INT     3
L34:
        BYTE    10
        BYTE    2
        BYTE    25
        BYTE    85
L33:
        MOV     #<TN t35[RAX]>, #<TN t34[RSI]>
        SUB     #<TN t35[RAX]>, #<TN t38[RSP]>
        SHR     #<TN t35[RAX]>, 2

VOP TAIL-CALL-VARIABLE t34[RSI] t33[RBX] t5[S1] t9[S0] 
        MOV     #<TN t55[RAX]>, #<TN t33[RBX]>
        LEA     #<TN t56[RCX]>, QWORD PTR [+#S(SB!C:FIXUP
                                               :NAME TAIL-CALL-VARIABLE
                                               :FLAVOR ASSEMBLY-ROUTINE
                                               :OFFSET NIL)]
        JMP     #<TN t56[RCX]>

L5:

VOP ODD-KEY-ARGS-ERROR 
        INT     3
L35:
        BYTE    10
        BYTE    1
        BYTE    32

Annotation number 3: fix for tail-call-variable
Pasted by: nyef
When:9 months, 1 day ago
Share:Tweet this! | http://paste.lisp.org/+1YO0/3
Paste contents:
Raw Source | Display As 
diff --git a/src/assembly/x86-64/assem-rtns.lisp b/src/assembly/x86-64/assem-rtns.lisp
index e7bef7a..13893d1 100644
--- a/src/assembly/x86-64/assem-rtns.lisp
+++ b/src/assembly/x86-64/assem-rtns.lisp
@@ -151,9 +151,11 @@
   ;; Calculate NARGS (as a fixnum)
   (move ecx esi)
   (inst sub ecx rsp-tn)
+  #!-#.(cl:if (cl:= sb!vm:word-shift sb!vm:n-fixnum-tag-bits) '(and) '(or))
+  (inst shr ecx (- word-shift n-fixnum-tag-bits))
 
   ;; Check for all the args fitting the registers.
-  (inst cmp ecx (fixnumize 3))
+  (inst cmp ecx (fixnumize register-arg-count))
   (inst jmp :le REGISTER-ARGS)
 
   ;; Save the OLD-FP and RETURN-PC because the blit is going to trash

Colorize as:
Show Line Numbers
Index of paste annotations: 1 | 2 | 3

Lisppaste pastes can be made by anyone at any time. Imagine a fearsomely comprehensive disclaimer of liability. Now fear, comprehensively.