From 94871002d2badbeee88c7c0c50b28bbc92b55179 Mon Sep 17 00:00:00 2001
From: Douglas Katzman <dougk@google.com>
Date: Fri, 17 Nov 2017 11:21:02 -0500
Subject: [PATCH] Delete all but 2 versions of MY-MAKE-WIRED-TN

Keep one for hppa, rename the other to MAKE-WIRED-TN* and use it
for everyone else. Call it with SC number instead of SC name.
---
 src/compiler/alpha/c-call.lisp  | 45 ++++++++++++-------------------
 src/compiler/arm/c-call.lisp    | 49 +++++++++++++++-------------------
 src/compiler/arm64/c-call.lisp  | 35 +++++++++++-------------
 src/compiler/mips/c-call.lisp   | 51 +++++++++++++----------------------
 src/compiler/ppc/c-call.lisp    | 59 +++++++++++++++++++----------------------
 src/compiler/sparc/c-call.lisp  | 31 +++++++++-------------
 src/compiler/tn.lisp            |  2 ++
 src/compiler/x86-64/c-call.lisp | 37 +++++++++++---------------
 src/compiler/x86/c-call.lisp    | 37 +++++++++++---------------
 9 files changed, 147 insertions(+), 199 deletions(-)

diff --git a/src/compiler/alpha/c-call.lisp b/src/compiler/alpha/c-call.lisp
index 48c73aef0..eef8f816a 100644
--- a/src/compiler/alpha/c-call.lisp
+++ b/src/compiler/alpha/c-call.lisp
@@ -11,11 +11,6 @@
 
 (in-package "SB!VM")
 
-(defun my-make-wired-tn (prim-type-name sc-name offset)
-  (make-wired-tn (primitive-type-or-lose prim-type-name )
-                 (sc-number-or-lose sc-name )
-                 offset))
-
 (defstruct arg-state
   (stack-frame-size 0))
 
@@ -25,22 +20,20 @@
     (multiple-value-bind
         (ptype reg-sc stack-sc)
         (if (alien-integer-type-signed type)
-            (values 'signed-byte-64 'signed-reg 'signed-stack)
-            (values 'unsigned-byte-64 'unsigned-reg 'unsigned-stack))
+            (values 'signed-byte-64 signed-reg-sc-number signed-stack-sc-number)
+            (values 'unsigned-byte-64 unsigned-reg-sc-number unsigned-stack-sc-number))
       (if (< stack-frame-size 4)
-          (my-make-wired-tn ptype reg-sc (+ stack-frame-size nl0-offset))
-          (my-make-wired-tn ptype stack-sc (* 2 (- stack-frame-size 4)))))))
+          (make-wired-tn* ptype reg-sc (+ stack-frame-size nl0-offset))
+          (make-wired-tn* ptype stack-sc (* 2 (- stack-frame-size 4)))))))
 
 (define-alien-type-method (system-area-pointer :arg-tn) (type state)
   (declare (ignore type))
   (let ((stack-frame-size (arg-state-stack-frame-size state)))
     (setf (arg-state-stack-frame-size state) (1+ stack-frame-size))
     (if (< stack-frame-size 4)
-        (my-make-wired-tn 'system-area-pointer
-                          'sap-reg
+        (make-wired-tn* 'system-area-pointer sap-reg-sc-number
                           (+ stack-frame-size nl0-offset))
-        (my-make-wired-tn 'system-area-pointer
-                          'sap-stack
+        (make-wired-tn* 'system-area-pointer sap-stack-sc-number
                           (* 2 (- stack-frame-size 4))))))
 
 (define-alien-type-method (double-float :arg-tn) (type state)
@@ -48,11 +41,9 @@
   (let ((stack-frame-size (arg-state-stack-frame-size state)))
     (setf (arg-state-stack-frame-size state) (1+ stack-frame-size))
     (if (< stack-frame-size 6)
-        (my-make-wired-tn 'double-float
-                          'double-reg
+        (make-wired-tn* 'double-float double-reg-sc-number
                           (+ stack-frame-size nl0-offset))
-        (my-make-wired-tn 'double-float
-                          'double-stack
+        (make-wired-tn* 'double-float double-stack-sc-number
                           (* 2 (- stack-frame-size 4))))))
 
 (define-alien-type-method (single-float :arg-tn) (type state)
@@ -60,11 +51,9 @@
   (let ((stack-frame-size (arg-state-stack-frame-size state)))
     (setf (arg-state-stack-frame-size state) (1+ stack-frame-size))
     (if (< stack-frame-size 6)
-        (my-make-wired-tn 'single-float
-                          'single-reg
+        (make-wired-tn* 'single-float single-reg-sc-number
                           (+ stack-frame-size nl0-offset))
-        (my-make-wired-tn 'single-float
-                          'single-stack
+        (make-wired-tn* 'single-float single-stack-sc-number
                           (* 2 (- stack-frame-size 4))))))
 
 (define-alien-type-method (integer :result-tn) (type state)
@@ -72,9 +61,9 @@
   (multiple-value-bind
       (ptype reg-sc)
       (if (alien-integer-type-signed type)
-          (values 'signed-byte-64 'signed-reg)
-          (values 'unsigned-byte-64 'unsigned-reg))
-    (my-make-wired-tn ptype reg-sc lip-offset)))
+          (values 'signed-byte-64 signed-reg-sc-number)
+          (values 'unsigned-byte-64 unsigned-reg-sc-number))
+    (make-wired-tn* ptype reg-sc lip-offset)))
 
 (define-alien-type-method (integer :naturalize-gen) (type alien)
   (if (<= (alien-type-bits type) 32)
@@ -85,15 +74,15 @@
 
 (define-alien-type-method (system-area-pointer :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'system-area-pointer 'sap-reg lip-offset))
+  (make-wired-tn* 'system-area-pointer sap-reg-sc-number lip-offset))
 
 (define-alien-type-method (double-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'double-float 'double-reg lip-offset))
+  (make-wired-tn* 'double-float double-reg-sc-number lip-offset))
 
 (define-alien-type-method (single-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'single-float 'single-reg lip-offset))
+  (make-wired-tn* 'single-float single-reg-sc-number lip-offset))
 
 (define-alien-type-method (values :result-tn) (type state)
   (let ((values (alien-values-type-values type)))
@@ -107,7 +96,7 @@
     (collect ((arg-tns))
       (dolist (arg-type (alien-fun-type-arg-types type))
         (arg-tns (invoke-alien-type-method :arg-tn arg-type arg-state)))
-      (values (my-make-wired-tn 'positive-fixnum 'any-reg nsp-offset)
+      (values (make-wired-tn* 'positive-fixnum any-reg-sc-number nsp-offset)
               (* (max (- (logandc2 (1+ (arg-state-stack-frame-size arg-state)) 1) 4) 2)
                  n-word-bytes
                  #.(floor n-machine-word-bits n-word-bits))
diff --git a/src/compiler/arm/c-call.lisp b/src/compiler/arm/c-call.lisp
index 9919efebb..d5143df8f 100644
--- a/src/compiler/arm/c-call.lisp
+++ b/src/compiler/arm/c-call.lisp
@@ -15,11 +15,6 @@
 
 (defconstant +max-register-args+ 4)
 
-(defun my-make-wired-tn (prim-type-name sc-name offset)
-  (make-wired-tn (primitive-type-or-lose prim-type-name)
-                 (sc-number-or-lose sc-name)
-                 offset))
-
 (defstruct arg-state
   (num-register-args 0)
   #!-arm-softfp
@@ -42,25 +37,25 @@
   (let ((reg-args (arg-state-num-register-args state)))
     (cond ((< reg-args +max-register-args+)
            (setf (arg-state-num-register-args state) (1+ reg-args))
-           (my-make-wired-tn prim-type reg-sc (register-args-offset reg-args)))
+           (make-wired-tn* prim-type reg-sc (register-args-offset reg-args)))
           (t
            (let ((frame-size (arg-state-stack-frame-size state)))
              (setf (arg-state-stack-frame-size state) (1+ frame-size))
-             (my-make-wired-tn prim-type stack-sc frame-size))))))
+             (make-wired-tn* prim-type stack-sc frame-size))))))
 
 (define-alien-type-method (integer :arg-tn) (type state)
   (if (alien-integer-type-signed type)
-      (int-arg state 'signed-byte-32 'signed-reg 'signed-stack)
-      (int-arg state 'unsigned-byte-32 'unsigned-reg 'unsigned-stack)))
+      (int-arg state 'signed-byte-32 signed-reg-sc-number signed-stack-sc-number)
+      (int-arg state 'unsigned-byte-32 unsigned-reg-sc-number unsigned-stack-sc-number)))
 
 (define-alien-type-method (system-area-pointer :arg-tn) (type state)
   (declare (ignore type))
-  (int-arg state 'system-area-pointer 'sap-reg 'sap-stack))
+  (int-arg state 'system-area-pointer sap-reg-sc-number sap-stack-sc-number))
 
 #!+arm-softfp
 (define-alien-type-method (single-float :arg-tn) (type state)
   (declare (ignore type))
-  (int-arg state 'single-float 'unsigned-reg 'single-stack))
+  (int-arg state 'single-float unsigned-reg-sc-number single-stack-sc-number))
 
 #!-arm-softfp
 (define-alien-type-method (single-float :arg-tn) (type state)
@@ -69,10 +64,10 @@
     (cond ((> register 15)
            (let ((frame-size (arg-state-stack-frame-size state)))
              (setf (arg-state-stack-frame-size state) (1+ frame-size))
-             (my-make-wired-tn 'single-float 'single-stack frame-size)))
+             (make-wired-tn* 'single-float single-stack-sc-number frame-size)))
           (t
            (incf (arg-state-fp-registers state))
-           (my-make-wired-tn 'single-float 'single-reg register)))))
+           (make-wired-tn* 'single-float single-reg-sc-number register)))))
 
 #!+arm-softfp
 (define-alien-type-method (double-float :arg-tn) (type state)
@@ -85,13 +80,13 @@
            (setf (arg-state-num-register-args state) +max-register-args+)
            (let ((frame-size (arg-state-stack-frame-size state)))
              (setf (arg-state-stack-frame-size state) (+ frame-size 2))
-             (my-make-wired-tn 'double-float 'double-stack frame-size)))
+             (make-wired-tn* 'double-float double-stack-sc-number frame-size)))
           (t
            (setf (arg-state-num-register-args state) (+ register 2))
            (list
-            (my-make-wired-tn 'unsigned-byte-32 'unsigned-reg
+            (make-wired-tn* 'unsigned-byte-32 unsigned-reg-sc-number
                               (register-args-offset register))
-            (my-make-wired-tn 'unsigned-byte-32 'unsigned-reg
+            (make-wired-tn* 'unsigned-byte-32 unsigned-reg-sc-number
                               (register-args-offset (1+ register)))
             'move-double-to-int-args)))))
 
@@ -106,46 +101,46 @@
                    (setf (arg-state-stack-frame-size state)
                          (logandc2 (+ (arg-state-stack-frame-size state) 1) 1))))
              (setf (arg-state-stack-frame-size state) (+ frame-size 2))
-             (my-make-wired-tn 'double-float 'double-stack frame-size)))
+             (make-wired-tn* 'double-float double-stack-sc-number frame-size)))
           (t
            (incf (arg-state-fp-registers state) 2)
-           (my-make-wired-tn 'double-float 'double-reg register)))))
+           (make-wired-tn* 'double-float double-reg-sc-number register)))))
 
 (define-alien-type-method (integer :result-tn) (type state)
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
     (multiple-value-bind (ptype reg-sc)
         (if (alien-integer-type-signed type)
-            (values 'signed-byte-32 'signed-reg)
-            (values 'unsigned-byte-32 'unsigned-reg))
-      (my-make-wired-tn ptype reg-sc
+            (values 'signed-byte-32 signed-reg-sc-number)
+            (values 'unsigned-byte-32 unsigned-reg-sc-number))
+      (make-wired-tn* ptype reg-sc
                         (result-reg-offset num-results)))))
 
 (define-alien-type-method (system-area-pointer :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'system-area-pointer 'sap-reg nargs-offset))
+  (make-wired-tn* 'system-area-pointer sap-reg-sc-number nargs-offset))
 
 #!+arm-softfp
 (define-alien-type-method (single-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'single-float 'unsigned-reg nargs-offset))
+  (make-wired-tn* 'single-float unsigned-reg-sc-number nargs-offset))
 
 #!-arm-softfp
 (define-alien-type-method (single-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'single-float 'single-reg 0))
+  (make-wired-tn* 'single-float single-reg-sc-number 0))
 
 #!+arm-softfp
 (define-alien-type-method (double-float :result-tn) (type state)
   (declare (ignore type state))
-  (list (my-make-wired-tn 'unsigned-byte-32 'unsigned-reg nargs-offset)
-        (my-make-wired-tn 'unsigned-byte-32 'unsigned-reg nl3-offset)
+  (list (make-wired-tn* 'unsigned-byte-32 unsigned-reg-sc-number nargs-offset)
+        (make-wired-tn* 'unsigned-byte-32 unsigned-reg-sc-number nl3-offset)
         'move-int-args-to-double))
 
 #!-arm-softfp
 (define-alien-type-method (double-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'double-float 'double-reg 0))
+  (make-wired-tn* 'double-float double-reg-sc-number 0))
 
 (define-alien-type-method (values :result-tn) (type state)
   (let ((values (alien-values-type-values type)))
diff --git a/src/compiler/arm64/c-call.lisp b/src/compiler/arm64/c-call.lisp
index a47f4a4d6..aa8315292 100644
--- a/src/compiler/arm64/c-call.lisp
+++ b/src/compiler/arm64/c-call.lisp
@@ -15,11 +15,6 @@
 
 (defconstant +max-register-args+ 8)
 
-(defun my-make-wired-tn (prim-type-name sc-name offset)
-  (make-wired-tn (primitive-type-or-lose prim-type-name)
-                 (sc-number-or-lose sc-name)
-                 offset))
-
 (defstruct arg-state
   (num-register-args 0)
   (fp-registers 0)
@@ -42,38 +37,38 @@
   (let ((reg-args (arg-state-num-register-args state)))
     (cond ((< reg-args +max-register-args+)
            (setf (arg-state-num-register-args state) (1+ reg-args))
-           (my-make-wired-tn prim-type reg-sc (register-args-offset reg-args)))
+           (make-wired-tn* prim-type reg-sc (register-args-offset reg-args)))
           (t
            (let ((frame-size (arg-state-stack-frame-size state)))
              (setf (arg-state-stack-frame-size state) (1+ frame-size))
-             (my-make-wired-tn prim-type stack-sc frame-size))))))
+             (make-wired-tn* prim-type stack-sc frame-size))))))
 
 (defun float-arg (state prim-type reg-sc stack-sc)
   (let ((reg-args (arg-state-fp-registers state)))
     (cond ((< reg-args +max-register-args+)
            (setf (arg-state-fp-registers state) (1+ reg-args))
-           (my-make-wired-tn prim-type reg-sc reg-args))
+           (make-wired-tn* prim-type reg-sc reg-args))
           (t
            (let ((frame-size (arg-state-stack-frame-size state)))
              (setf (arg-state-stack-frame-size state) (1+ frame-size))
-             (my-make-wired-tn prim-type stack-sc frame-size))))))
+             (make-wired-tn* prim-type stack-sc frame-size))))))
 
 (define-alien-type-method (integer :arg-tn) (type state)
   (if (alien-integer-type-signed type)
-      (int-arg state 'signed-byte-64 'signed-reg 'signed-stack)
-      (int-arg state 'unsigned-byte-64 'unsigned-reg 'unsigned-stack)))
+      (int-arg state 'signed-byte-64 signed-reg-sc-number 'signed-stack)
+      (int-arg state 'unsigned-byte-64 unsigned-reg-sc-number 'unsigned-stack)))
 
 (define-alien-type-method (system-area-pointer :arg-tn) (type state)
   (declare (ignore type))
-  (int-arg state 'system-area-pointer 'sap-reg 'sap-stack))
+  (int-arg state 'system-area-pointer sap-reg-sc-number sap-stack-sc-number))
 
 (define-alien-type-method (single-float :arg-tn) (type state)
   (declare (ignore type))
-  (float-arg state 'single-float 'single-reg 'single-stack))
+  (float-arg state 'single-float single-reg-sc-number single-stack-sc-number))
 
 (define-alien-type-method (double-float :arg-tn) (type state)
   (declare (ignore type))
-  (float-arg state 'double-float 'double-reg 'double-stack))
+  (float-arg state 'double-float double-reg-sc-number double-stack-sc-number))
 ;;;
 
 (defknown sign-extend ((signed-byte 64) t) fixnum
@@ -117,23 +112,23 @@
     (setf (result-state-num-results state) (1+ num-results))
     (multiple-value-bind (ptype reg-sc)
         (if (alien-integer-type-signed type)
-            (values 'signed-byte-64 'signed-reg)
-            (values 'unsigned-byte-64 'unsigned-reg))
-      (my-make-wired-tn ptype reg-sc
+            (values 'signed-byte-64 signed-reg-sc-number)
+            (values 'unsigned-byte-64 unsigned-reg-sc-number))
+      (make-wired-tn* ptype reg-sc
                         (result-reg-offset num-results)))))
 
 (define-alien-type-method (system-area-pointer :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'system-area-pointer 'sap-reg (result-reg-offset 0)))
+  (make-wired-tn* 'system-area-pointer sap-reg-sc-number (result-reg-offset 0)))
 
 
 (define-alien-type-method (single-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'single-float 'single-reg 0))
+  (make-wired-tn* 'single-float single-reg-sc-number 0))
 
 (define-alien-type-method (double-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'double-float 'double-reg 0))
+  (make-wired-tn* 'double-float double-reg-sc-number 0))
 
 (define-alien-type-method (values :result-tn) (type state)
   (let ((values (alien-values-type-values type)))
diff --git a/src/compiler/mips/c-call.lisp b/src/compiler/mips/c-call.lisp
index d3e936903..a9f6995ac 100644
--- a/src/compiler/mips/c-call.lisp
+++ b/src/compiler/mips/c-call.lisp
@@ -11,11 +11,6 @@
 
 (in-package "SB!VM")
 
-(defun my-make-wired-tn (prim-type-name sc-name offset)
-  (make-wired-tn (primitive-type-or-lose prim-type-name)
-                 (sc-number-or-lose sc-name)
-                 offset))
-
 (defstruct arg-state
   (stack-frame-size 0)
   (did-int-arg nil)
@@ -28,11 +23,11 @@
     (multiple-value-bind
         (ptype reg-sc stack-sc)
         (if (alien-integer-type-signed type)
-            (values 'signed-byte-32 'signed-reg 'signed-stack)
-            (values 'unsigned-byte-32 'unsigned-reg 'unsigned-stack))
+            (values 'signed-byte-32 signed-reg-sc-number signed-stack-sc-number)
+            (values 'unsigned-byte-32 unsigned-reg-sc-number unsigned-stack-sc-number))
       (if (< stack-frame-size 4)
-          (my-make-wired-tn ptype reg-sc (+ stack-frame-size 4))
-          (my-make-wired-tn ptype stack-sc stack-frame-size)))))
+          (make-wired-tn* ptype reg-sc (+ stack-frame-size 4))
+          (make-wired-tn* ptype stack-sc stack-frame-size)))))
 
 (define-alien-type-method (system-area-pointer :arg-tn) (type state)
   (declare (ignore type))
@@ -40,11 +35,9 @@
     (setf (arg-state-stack-frame-size state) (1+ stack-frame-size))
     (setf (arg-state-did-int-arg state) t)
     (if (< stack-frame-size 4)
-        (my-make-wired-tn 'system-area-pointer
-                          'sap-reg
+        (make-wired-tn* 'system-area-pointer sap-reg-sc-number
                           (+ stack-frame-size 4))
-        (my-make-wired-tn 'system-area-pointer
-                          'sap-stack
+        (make-wired-tn* 'system-area-pointer sap-stack-sc-number
                           stack-frame-size))))
 
 (define-alien-type-method (double-float :arg-tn) (type state)
@@ -54,17 +47,14 @@
     (setf (arg-state-stack-frame-size state) (+ stack-frame-size 2))
     (setf (arg-state-float-args state) (1+ float-args))
     (cond ((>= stack-frame-size 4)
-           (my-make-wired-tn 'double-float
-                             'double-stack
+           (make-wired-tn* 'double-float double-stack-sc-number
                              stack-frame-size))
           ((and (not (arg-state-did-int-arg state))
                 (< float-args 2))
-           (my-make-wired-tn 'double-float
-                             'double-reg
+           (make-wired-tn* 'double-float double-reg-sc-number
                              (+ (* float-args 2) 12)))
           (t
-           (my-make-wired-tn 'double-float
-                             'double-int-carg-reg
+           (make-wired-tn* 'double-float double-int-carg-reg-sc-number
                              (+ stack-frame-size 4))))))
 
 (define-alien-type-method (single-float :arg-tn) (type state)
@@ -74,17 +64,14 @@
     (setf (arg-state-stack-frame-size state) (1+ stack-frame-size))
     (setf (arg-state-float-args state) (1+ float-args))
     (cond ((>= stack-frame-size 4)
-           (my-make-wired-tn 'single-float
-                             'single-stack
+           (make-wired-tn* 'single-float single-stack-sc-number
                              stack-frame-size))
           ((and (not (arg-state-did-int-arg state))
                 (< float-args 2))
-           (my-make-wired-tn 'single-float
-                             'single-reg
+           (make-wired-tn* 'single-float single-reg-sc-number
                              (+ (* float-args 2) 12)))
           (t
-           (my-make-wired-tn 'single-float
-                             'single-int-carg-reg
+           (make-wired-tn* 'single-float single-int-carg-reg-sc-number
                              (+ stack-frame-size 4))))))
 
 (defstruct result-state
@@ -100,28 +87,28 @@
     (setf (result-state-num-results state) (1+ num-results))
     (multiple-value-bind (ptype reg-sc)
         (if (alien-integer-type-signed type)
-            (values 'signed-byte-32 'signed-reg)
-            (values 'unsigned-byte-32 'unsigned-reg))
-      (my-make-wired-tn ptype reg-sc (result-reg-offset num-results)))))
+            (values 'signed-byte-32 signed-reg-sc-number)
+            (values 'unsigned-byte-32 unsigned-reg-sc-number))
+      (make-wired-tn* ptype reg-sc (result-reg-offset num-results)))))
 
 (define-alien-type-method (system-area-pointer :result-tn) (type state)
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'system-area-pointer 'sap-reg (result-reg-offset num-results))))
+    (make-wired-tn* 'system-area-pointer sap-reg-sc-number (result-reg-offset num-results))))
 
 ;;; FIXME: do these still work? -- CSR, 2002-08-28
 (define-alien-type-method (double-float :result-tn) (type state)
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'double-float 'double-reg (* num-results 2))))
+    (make-wired-tn* 'double-float double-reg-sc-number (* num-results 2))))
 
 (define-alien-type-method (single-float :result-tn) (type state)
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'single-float 'single-reg (* num-results 2))))
+    (make-wired-tn* 'single-float single-reg-sc-number (* num-results 2))))
 
 (define-alien-type-method (values :result-tn) (type state)
   (let ((values (alien-values-type-values type)))
@@ -136,7 +123,7 @@
     (collect ((arg-tns))
       (dolist (arg-type (alien-fun-type-arg-types type))
         (arg-tns (invoke-alien-type-method :arg-tn arg-type arg-state)))
-      (values (my-make-wired-tn 'positive-fixnum 'any-reg nsp-offset)
+      (values (make-wired-tn* 'positive-fixnum any-reg-sc-number nsp-offset)
               (* (max (arg-state-stack-frame-size arg-state) 4) n-word-bytes)
               (arg-tns)
               (invoke-alien-type-method :result-tn
diff --git a/src/compiler/ppc/c-call.lisp b/src/compiler/ppc/c-call.lisp
index d607158e6..63b0edf24 100644
--- a/src/compiler/ppc/c-call.lisp
+++ b/src/compiler/ppc/c-call.lisp
@@ -23,11 +23,6 @@
   ;; But Darwin doesn't
   #!+darwin 15)
 
-(defun my-make-wired-tn (prim-type-name sc-name offset)
-  (make-wired-tn (primitive-type-or-lose prim-type-name)
-                 (sc-number-or-lose sc-name)
-                 offset))
-
 (defstruct arg-state
   (gpr-args 0)
   (fpr-args 0)
@@ -42,20 +37,20 @@
   (let ((reg-args (arg-state-gpr-args state)))
     (cond ((< reg-args 8)
            (setf (arg-state-gpr-args state) (1+ reg-args))
-           (my-make-wired-tn prim-type reg-sc (+ reg-args nl0-offset)))
+           (make-wired-tn* prim-type reg-sc (+ reg-args nl0-offset)))
           (t
            (let ((frame-size (arg-state-stack-frame-size state)))
              (setf (arg-state-stack-frame-size state) (1+ frame-size))
-             (my-make-wired-tn prim-type stack-sc frame-size))))))
+             (make-wired-tn* prim-type stack-sc frame-size))))))
 
 (define-alien-type-method (integer :arg-tn) (type state)
   (if (alien-integer-type-signed type)
-      (int-arg state 'signed-byte-32 'signed-reg 'signed-stack)
-      (int-arg state 'unsigned-byte-32 'unsigned-reg 'unsigned-stack)))
+      (int-arg state 'signed-byte-32 signed-reg-sc-number signed-stack-sc-number)
+      (int-arg state 'unsigned-byte-32 unsigned-reg-sc-number unsigned-stack-sc-number)))
 
 (define-alien-type-method (system-area-pointer :arg-tn) (type state)
   (declare (ignore type))
-  (int-arg state 'system-area-pointer 'sap-reg 'sap-stack))
+  (int-arg state 'system-area-pointer sap-reg-sc-number sap-stack-sc-number))
 
 ;;; The Linux/PPC 32bit ABI says:
 ;;;
@@ -74,11 +69,11 @@
     (cond ((< fprs 8)
            (incf (arg-state-fpr-args state))
            ;; Assign outgoing FPRs starting at FP1
-           (my-make-wired-tn 'single-float 'single-reg (1+ fprs)))
+           (make-wired-tn* 'single-float single-reg-sc-number (1+ fprs)))
           (t
            (let* ((stack-offset (arg-state-stack-frame-size state)))
              (setf (arg-state-stack-frame-size state) (+ stack-offset 1))
-             (my-make-wired-tn 'single-float 'single-stack stack-offset))))))
+             (make-wired-tn* 'single-float single-stack-sc-number stack-offset))))))
 
 ;;; If a single-float arg has to go on the stack, it's promoted to
 ;;; double.  That way, C programs can get subtle rounding errors when
@@ -91,18 +86,18 @@
     (cond ((< gprs 8) ; and by implication also (< fprs 13)
            (incf (arg-state-fpr-args state))
            ;; Assign outgoing FPRs starting at FP1
-           (list (my-make-wired-tn 'single-float 'single-reg (1+ fprs))
-                 (int-arg state 'signed-byte-32 'signed-reg 'signed-stack)))
+           (list (make-wired-tn* 'single-float single-reg-sc-number (1+ fprs))
+                 (int-arg state 'signed-byte-32 signed-reg-sc-number signed-stack-sc-number)))
           ((< fprs 13)
            ;; See comments below for double-float.
            (incf (arg-state-fpr-args state))
            (incf (arg-state-stack-frame-size state))
-           (my-make-wired-tn 'single-float 'single-reg (1+ fprs)))
+           (make-wired-tn* 'single-float single-reg-sc-number (1+ fprs)))
           (t
            ;; Pass on stack only
            (let ((stack-offset (arg-state-stack-frame-size state)))
              (incf (arg-state-stack-frame-size state))
-             (my-make-wired-tn 'single-float 'single-stack stack-offset))))))
+             (make-wired-tn* 'single-float single-stack-sc-number stack-offset))))))
 
 #!-darwin
 (define-alien-type-method (double-float :arg-tn) (type state)
@@ -111,13 +106,13 @@
     (cond ((< fprs 8)
            (incf (arg-state-fpr-args state))
            ;; Assign outgoing FPRs starting at FP1
-           (my-make-wired-tn 'double-float 'double-reg (1+ fprs)))
+           (make-wired-tn* 'double-float double-reg-sc-number (1+ fprs)))
           (t
            (let* ((stack-offset (arg-state-stack-frame-size state)))
              (if (oddp stack-offset)
                (incf stack-offset))
              (setf (arg-state-stack-frame-size state) (+ stack-offset 2))
-             (my-make-wired-tn 'double-float 'double-stack stack-offset))))))
+             (make-wired-tn* 'double-float double-stack-sc-number stack-offset))))))
 
 #!+darwin
 (define-alien-type-method (double-float :arg-tn) (type state)
@@ -134,19 +129,19 @@
            ;; to %alien-funcall ir2-convert by making a list of the
            ;; TNs for the float reg and for the int regs.
            ;;
-           (list (my-make-wired-tn 'double-float 'double-reg (1+ fprs))
-                 (int-arg state 'signed-byte-32 'signed-reg 'signed-stack)
-                 (int-arg state 'unsigned-byte-32 'unsigned-reg 'unsigned-stack)))
+           (list (make-wired-tn* 'double-float double-reg-sc-number (1+ fprs))
+                 (int-arg state 'signed-byte-32 signed-reg-sc-number signed-stack-sc-number)
+                 (int-arg state 'unsigned-byte-32 unsigned-reg-sc-number unsigned-stack-sc-number)))
           ((< fprs 13)
            (incf (arg-state-fpr-args state))
-           (list (my-make-wired-tn 'double-float 'double-reg (1+ fprs))
-                 (int-arg state 'signed-byte-32 'signed-reg 'signed-stack)
-                 (int-arg state 'unsigned-byte-32 'unsigned-reg 'unsigned-stack)))
+           (list (make-wired-tn* 'double-float double-reg-sc-number (1+ fprs))
+                 (int-arg state 'signed-byte-32 signed-reg-sc-number signed-stack-sc-number)
+                 (int-arg state 'unsigned-byte-32 unsigned-reg-sc-number unsigned-stack-sc-number)))
           (t
            ;; Pass on stack only
            (let ((stack-offset (arg-state-stack-frame-size state)))
              (incf (arg-state-stack-frame-size state) 2)
-             (my-make-wired-tn 'double-float 'double-stack stack-offset))))))
+             (make-wired-tn* 'double-float double-stack-sc-number stack-offset))))))
 
 ;;; Result state handling
 
@@ -167,16 +162,16 @@
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'system-area-pointer 'sap-reg
+    (make-wired-tn* 'system-area-pointer sap-reg-sc-number
                       (result-reg-offset num-results))))
 
 (define-alien-type-method (single-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'single-float 'single-reg 1))
+  (make-wired-tn* 'single-float single-reg-sc-number 1))
 
 (define-alien-type-method (double-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'double-float 'double-reg 1))
+  (make-wired-tn* 'double-float double-reg-sc-number 1))
 
 (define-alien-type-method (values :result-tn) (type state)
   (let ((values (alien-values-type-values type)))
@@ -191,9 +186,9 @@
     (setf (result-state-num-results state) (1+ num-results))
     (multiple-value-bind (ptype reg-sc)
         (if (alien-integer-type-signed type)
-            (values 'signed-byte-32 'signed-reg)
-            (values 'unsigned-byte-32 'unsigned-reg))
-      (my-make-wired-tn ptype reg-sc (result-reg-offset num-results)))))
+            (values 'signed-byte-32 signed-reg-sc-number)
+            (values 'unsigned-byte-32 unsigned-reg-sc-number))
+      (make-wired-tn* ptype reg-sc (result-reg-offset num-results)))))
 
 (defun make-call-out-tns (type)
   (declare (type alien-fun-type type))
@@ -201,7 +196,7 @@
     (collect ((arg-tns))
       (dolist (arg-type (alien-fun-type-arg-types type))
         (arg-tns (invoke-alien-type-method :arg-tn arg-type arg-state)))
-      (values (my-make-wired-tn 'positive-fixnum 'any-reg nsp-offset)
+      (values (make-wired-tn* 'positive-fixnum any-reg-sc-number nsp-offset)
               (* (arg-state-stack-frame-size arg-state) n-word-bytes)
               (arg-tns)
               (invoke-alien-type-method
diff --git a/src/compiler/sparc/c-call.lisp b/src/compiler/sparc/c-call.lisp
index 09dc7e8dc..daa8608d2 100644
--- a/src/compiler/sparc/c-call.lisp
+++ b/src/compiler/sparc/c-call.lisp
@@ -11,11 +11,6 @@
 
 (in-package "SB!VM")
 
-(defun my-make-wired-tn (prim-type-name sc-name offset)
-  (make-wired-tn (primitive-type-or-lose prim-type-name)
-                 (sc-number-or-lose sc-name)
-                 offset))
-
 (defstruct arg-state
   (register-args 0)
   ;; No matter what we have to allocate at least 7 stack frame slots.  One
@@ -27,20 +22,20 @@
   (let ((reg-args (arg-state-register-args state)))
     (cond ((< reg-args 6)
            (setf (arg-state-register-args state) (1+ reg-args))
-           (my-make-wired-tn prim-type reg-sc (+ reg-args nl0-offset)))
+           (make-wired-tn* prim-type reg-sc (+ reg-args nl0-offset)))
           (t
            (let ((frame-size (arg-state-stack-frame-size state)))
              (setf (arg-state-stack-frame-size state) (1+ frame-size))
-             (my-make-wired-tn prim-type stack-sc (+ frame-size 16)))))))
+             (make-wired-tn* prim-type stack-sc (+ frame-size 16)))))))
 
 (define-alien-type-method (integer :arg-tn) (type state)
   (if (alien-integer-type-signed type)
-      (int-arg state 'signed-byte-32 'signed-reg 'signed-stack)
-      (int-arg state 'unsigned-byte-32 'unsigned-reg 'unsigned-stack)))
+      (int-arg state 'signed-byte-32 signed-reg-sc-number signed-stack-sc-number)
+      (int-arg state 'unsigned-byte-32 unsigned-reg-sc-number unsigned-stack-sc-number)))
 
 (define-alien-type-method (system-area-pointer :arg-tn) (type state)
   (declare (ignore type))
-  (int-arg state 'system-area-pointer 'sap-reg 'sap-stack))
+  (int-arg state 'system-area-pointer sap-reg-sc-number sap-stack-sc-number))
 
 (defstruct result-state
   (num-results 0))
@@ -55,29 +50,29 @@
     (setf (result-state-num-results state) (1+ num-results))
     (multiple-value-bind (ptype reg-sc)
         (if (alien-integer-type-signed type)
-            (values 'signed-byte-32 'signed-reg)
-            (values 'unsigned-byte-32 'unsigned-reg))
-      (my-make-wired-tn ptype reg-sc (result-reg-offset num-results)))))
+            (values 'signed-byte-32 signed-reg-sc-number)
+            (values 'unsigned-byte-32 unsigned-reg-sc-number))
+      (make-wired-tn* ptype reg-sc (result-reg-offset num-results)))))
 
 (define-alien-type-method (system-area-pointer :result-tn) (type state)
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'system-area-pointer 'sap-reg
+    (make-wired-tn* 'system-area-pointer sap-reg-sc-number
                       (result-reg-offset num-results))))
 
 (define-alien-type-method (double-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'double-float 'double-reg 0))
+  (make-wired-tn* 'double-float double-reg-sc-number 0))
 
 (define-alien-type-method (single-float :result-tn) (type state)
   (declare (ignore type state))
-  (my-make-wired-tn 'single-float 'single-reg 0))
+  (make-wired-tn* 'single-float single-reg-sc-number 0))
 
 #!+long-float
 (define-alien-type-method (long-float :result-tn) (type)
   (declare (ignore type))
-  (my-make-wired-tn 'long-float 'long-reg 0))
+  (make-wired-tn* 'long-float long-reg-sc-number 0))
 
 (define-alien-type-method (values :result-tn) (type state)
   (let ((values (alien-values-type-values type)))
@@ -93,7 +88,7 @@
     (collect ((arg-tns))
       (dolist (arg-type (alien-fun-type-arg-types type))
         (arg-tns (invoke-alien-type-method :arg-tn arg-type arg-state)))
-      (values (my-make-wired-tn 'positive-fixnum 'any-reg nsp-offset)
+      (values (make-wired-tn* 'positive-fixnum any-reg-sc-number nsp-offset)
               (* (arg-state-stack-frame-size arg-state) n-word-bytes)
               (arg-tns)
               (invoke-alien-type-method
diff --git a/src/compiler/tn.lisp b/src/compiler/tn.lisp
index 3d8f23c22..ae075b0e0 100644
--- a/src/compiler/tn.lisp
+++ b/src/compiler/tn.lisp
@@ -141,6 +141,8 @@
     (setf (tn-offset res) offset)
     (push-in tn-next res (ir2-component-wired-tns component))
     res))
+(defun sb!vm::make-wired-tn* (prim-type-name scn offset)
+  (make-wired-tn (primitive-type-or-lose prim-type-name) scn offset))
 
 ;;; Create a packed TN restricted to the SC with number SCN. Ptype is as
 ;;; for MAKE-WIRED-TN.
diff --git a/src/compiler/x86-64/c-call.lisp b/src/compiler/x86-64/c-call.lisp
index eddb715b2..2a20f5911 100644
--- a/src/compiler/x86-64/c-call.lisp
+++ b/src/compiler/x86-64/c-call.lisp
@@ -17,11 +17,6 @@
 ;; used for things going down the stack but C wants to have args
 ;; indexed in the positive direction.
 
-(defun my-make-wired-tn (prim-type-name sc-name offset)
-  (make-wired-tn (primitive-type-or-lose prim-type-name)
-                 (sc-number-or-lose sc-name)
-                 offset))
-
 (defstruct (arg-state (:copier nil))
   (register-args 0)
   (xmm-args 0)
@@ -35,41 +30,41 @@
                        #!+win32 (arg-state-xmm-args state))))
     (cond ((< reg-args max-int-args)
            (setf (arg-state-register-args state) (1+ reg-args))
-           (my-make-wired-tn prim-type reg-sc
+           (make-wired-tn* prim-type reg-sc
                              (nth reg-args *c-call-register-arg-offsets*)))
           (t
            (let ((frame-size (arg-state-stack-frame-size state)))
              (setf (arg-state-stack-frame-size state) (1+ frame-size))
-             (my-make-wired-tn prim-type stack-sc frame-size))))))
+             (make-wired-tn* prim-type stack-sc frame-size))))))
 
 (define-alien-type-method (integer :arg-tn) (type state)
   (if (alien-integer-type-signed type)
-      (int-arg state 'signed-byte-64 'signed-reg 'signed-stack)
-      (int-arg state 'unsigned-byte-64 'unsigned-reg 'unsigned-stack)))
+      (int-arg state 'signed-byte-64 signed-reg-sc-number signed-stack-sc-number)
+      (int-arg state 'unsigned-byte-64 unsigned-reg-sc-number unsigned-stack-sc-number)))
 
 (define-alien-type-method (system-area-pointer :arg-tn) (type state)
   (declare (ignore type))
-  (int-arg state 'system-area-pointer 'sap-reg 'sap-stack))
+  (int-arg state 'system-area-pointer sap-reg-sc-number sap-stack-sc-number))
 
 (defun float-arg (state prim-type reg-sc stack-sc)
   (let ((xmm-args (max (arg-state-xmm-args state)
                         #!+win32 (arg-state-register-args state))))
     (cond ((< xmm-args max-xmm-args)
            (setf (arg-state-xmm-args state) (1+ xmm-args))
-           (my-make-wired-tn prim-type reg-sc
+           (make-wired-tn* prim-type reg-sc
                              (nth xmm-args *float-regs*)))
           (t
            (let ((frame-size (arg-state-stack-frame-size state)))
              (setf (arg-state-stack-frame-size state) (1+ frame-size))
-             (my-make-wired-tn prim-type stack-sc frame-size))))))
+             (make-wired-tn* prim-type stack-sc frame-size))))))
 
 (define-alien-type-method (double-float :arg-tn) (type state)
   (declare (ignore type))
-  (float-arg state 'double-float 'double-reg 'double-stack))
+  (float-arg state 'double-float double-reg-sc-number double-stack-sc-number))
 
 (define-alien-type-method (single-float :arg-tn) (type state)
   (declare (ignore type))
-  (float-arg state 'single-float 'single-reg 'single-stack))
+  (float-arg state 'single-float single-reg-sc-number single-stack-sc-number))
 
 (defstruct (result-state (:copier nil))
   (num-results 0))
@@ -84,9 +79,9 @@
     (setf (result-state-num-results state) (1+ num-results))
     (multiple-value-bind (ptype reg-sc)
         (if (alien-integer-type-signed type)
-            (values 'signed-byte-64 'signed-reg)
-            (values 'unsigned-byte-64 'unsigned-reg))
-      (my-make-wired-tn ptype reg-sc (result-reg-offset num-results)))))
+            (values 'signed-byte-64 signed-reg-sc-number)
+            (values 'unsigned-byte-64 unsigned-reg-sc-number))
+      (make-wired-tn* ptype reg-sc (result-reg-offset num-results)))))
 
 (define-alien-type-method (integer :naturalize-gen) (type alien)
   (if (<= (alien-type-bits type) 32)
@@ -99,20 +94,20 @@
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'system-area-pointer 'sap-reg
+    (make-wired-tn* 'system-area-pointer sap-reg-sc-number
                       (result-reg-offset num-results))))
 
 (define-alien-type-method (double-float :result-tn) (type state)
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'double-float 'double-reg num-results)))
+    (make-wired-tn* 'double-float double-reg-sc-number num-results)))
 
 (define-alien-type-method (single-float :result-tn) (type state)
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'single-float 'single-reg num-results)))
+    (make-wired-tn* 'single-float single-reg-sc-number num-results)))
 
 (define-alien-type-method (values :result-tn) (type state)
   (let ((values (alien-values-type-values type)))
@@ -127,7 +122,7 @@
     (collect ((arg-tns))
       (dolist (arg-type (alien-fun-type-arg-types type))
         (arg-tns (invoke-alien-type-method :arg-tn arg-type arg-state)))
-      (values (my-make-wired-tn 'positive-fixnum 'any-reg esp-offset)
+      (values (make-wired-tn* 'positive-fixnum any-reg-sc-number esp-offset)
               (* (arg-state-stack-frame-size arg-state) n-word-bytes)
               (arg-tns)
               (invoke-alien-type-method :result-tn
diff --git a/src/compiler/x86/c-call.lisp b/src/compiler/x86/c-call.lisp
index 09eed1f7e..5a87d339a 100644
--- a/src/compiler/x86/c-call.lisp
+++ b/src/compiler/x86/c-call.lisp
@@ -17,11 +17,6 @@
 ;; used for things going down the stack but C wants to have args
 ;; indexed in the positive direction.
 
-(defun my-make-wired-tn (prim-type-name sc-name offset)
-  (make-wired-tn (primitive-type-or-lose prim-type-name)
-                 (sc-number-or-lose sc-name)
-                 offset))
-
 (defstruct (arg-state (:copier nil))
   (stack-frame-size 0))
 
@@ -30,16 +25,16 @@
     (setf (arg-state-stack-frame-size state) (1+ stack-frame-size))
     (multiple-value-bind (ptype stack-sc)
         (if (alien-integer-type-signed type)
-            (values 'signed-byte-32 'signed-stack)
-            (values 'unsigned-byte-32 'unsigned-stack))
-      (my-make-wired-tn ptype stack-sc stack-frame-size))))
+            (values 'signed-byte-32 signed-stack-sc-number)
+            (values 'unsigned-byte-32 unsigned-stack-sc-number))
+      (make-wired-tn* ptype stack-sc stack-frame-size))))
 
 (define-alien-type-method (system-area-pointer :arg-tn) (type state)
   (declare (ignore type))
   (let ((stack-frame-size (arg-state-stack-frame-size state)))
     (setf (arg-state-stack-frame-size state) (1+ stack-frame-size))
-    (my-make-wired-tn 'system-area-pointer
-                      'sap-stack
+    (make-wired-tn* 'system-area-pointer
+                      sap-stack-sc-number
                       stack-frame-size)))
 
 #!+long-float
@@ -47,19 +42,19 @@
   (declare (ignore type))
   (let ((stack-frame-size (arg-state-stack-frame-size state)))
     (setf (arg-state-stack-frame-size state) (+ stack-frame-size 3))
-    (my-make-wired-tn 'long-float 'long-stack stack-frame-size)))
+    (make-wired-tn* 'long-float long-stack-sc-number stack-frame-size)))
 
 (define-alien-type-method (double-float :arg-tn) (type state)
   (declare (ignore type))
   (let ((stack-frame-size (arg-state-stack-frame-size state)))
     (setf (arg-state-stack-frame-size state) (+ stack-frame-size 2))
-    (my-make-wired-tn 'double-float 'double-stack stack-frame-size)))
+    (make-wired-tn* 'double-float double-stack-sc-number stack-frame-size)))
 
 (define-alien-type-method (single-float :arg-tn) (type state)
   (declare (ignore type))
   (let ((stack-frame-size (arg-state-stack-frame-size state)))
     (setf (arg-state-stack-frame-size state) (1+ stack-frame-size))
-    (my-make-wired-tn 'single-float 'single-stack stack-frame-size)))
+    (make-wired-tn* 'single-float single-stack-sc-number stack-frame-size)))
 
 (defstruct (result-state (:copier nil))
   (num-results 0))
@@ -74,9 +69,9 @@
     (setf (result-state-num-results state) (1+ num-results))
     (multiple-value-bind (ptype reg-sc)
         (if (alien-integer-type-signed type)
-            (values 'signed-byte-32 'signed-reg)
-            (values 'unsigned-byte-32 'unsigned-reg))
-      (my-make-wired-tn ptype reg-sc (result-reg-offset num-results)))))
+            (values 'signed-byte-32 signed-reg-sc-number)
+            (values 'unsigned-byte-32 unsigned-reg-sc-number))
+      (make-wired-tn* ptype reg-sc (result-reg-offset num-results)))))
 
 (define-alien-type-method (integer :naturalize-gen) (type alien)
   (if (<= (alien-type-bits type) 16)
@@ -89,7 +84,7 @@
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'system-area-pointer 'sap-reg
+    (make-wired-tn* 'system-area-pointer sap-reg-sc-number
                       (result-reg-offset num-results))))
 
 #!+long-float
@@ -97,19 +92,19 @@
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'long-float 'long-reg (* num-results 2))))
+    (make-wired-tn* 'long-float long-reg-sc-number (* num-results 2))))
 
 (define-alien-type-method (double-float :result-tn) (type state)
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'double-float 'double-reg (* num-results 2))))
+    (make-wired-tn* 'double-float double-reg-sc-number (* num-results 2))))
 
 (define-alien-type-method (single-float :result-tn) (type state)
   (declare (ignore type))
   (let ((num-results (result-state-num-results state)))
     (setf (result-state-num-results state) (1+ num-results))
-    (my-make-wired-tn 'single-float 'single-reg (* num-results 2))))
+    (make-wired-tn* 'single-float single-reg-sc-number (* num-results 2))))
 
 (define-alien-type-method (values :result-tn) (type state)
   (let ((values (alien-values-type-values type)))
@@ -124,7 +119,7 @@
     (collect ((arg-tns))
       (dolist (arg-type (alien-fun-type-arg-types type))
         (arg-tns (invoke-alien-type-method :arg-tn arg-type arg-state)))
-      (values (my-make-wired-tn 'positive-fixnum 'any-reg esp-offset)
+      (values (make-wired-tn* 'positive-fixnum any-reg-sc-number esp-offset)
               (* (arg-state-stack-frame-size arg-state) n-word-bytes)
               (arg-tns)
               (invoke-alien-type-method :result-tn
-- 
2.11.4.GIT