ppc64: Set n-fixnum-tag-bits = 3

This theoretically allows use of #b0100 and #b1100 as pointer lowtags
which would be more efficient in 8-byte load/store instructions.

float-math.lisp-expr

@@ -38,6 +38,9 @@
 (< (#.(MAKE-SINGLE-FLOAT #x4E000000) #.(MAKE-SINGLE-FLOAT #x4E000000)) NIL)
 (< (#.(MAKE-SINGLE-FLOAT #x5883126F) #.(MAKE-SINGLE-FLOAT #x0)) NIL)
 (< (#.(MAKE-SINGLE-FLOAT #x5883126F) #.(MAKE-SINGLE-FLOAT #x5883126F)) NIL)
+(< (#.(MAKE-SINGLE-FLOAT #x5D800000) #.(MAKE-SINGLE-FLOAT #x-22800000)) NIL)
+(< (#.(MAKE-SINGLE-FLOAT #x5D800000) #.(MAKE-SINGLE-FLOAT #x0)) NIL)
+(< (#.(MAKE-SINGLE-FLOAT #x5D800000) #.(MAKE-SINGLE-FLOAT #x5D800000)) NIL)
 (< (#.(MAKE-SINGLE-FLOAT #x5E800000) #.(MAKE-SINGLE-FLOAT #x-21800000)) NIL)
 (< (#.(MAKE-SINGLE-FLOAT #x5E800000) #.(MAKE-SINGLE-FLOAT #x0)) NIL)
 (< (#.(MAKE-SINGLE-FLOAT #x5E800000) #.(MAKE-SINGLE-FLOAT #x5E800000)) NIL)
@@ -57,6 +60,9 @@
 (< (#.(MAKE-DOUBLE-FLOAT #x41BFFFFF #xFF000000) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) NIL)
 (< (#.(MAKE-DOUBLE-FLOAT #x41BFFFFF #xFF000000) #.(MAKE-DOUBLE-FLOAT #x41BFFFFF #xFF000000)) NIL)
 (< (#.(MAKE-DOUBLE-FLOAT #x4310624D #xD2F1A9F8) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) NIL)
+(< (#.(MAKE-DOUBLE-FLOAT #x43B00000 #x0) #.(MAKE-DOUBLE-FLOAT #x-3C500000 #x0)) NIL)
+(< (#.(MAKE-DOUBLE-FLOAT #x43B00000 #x0) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) NIL)
+(< (#.(MAKE-DOUBLE-FLOAT #x43B00000 #x0) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0)) NIL)
 (< (#.(MAKE-DOUBLE-FLOAT #x43D00000 #x0) #.(MAKE-DOUBLE-FLOAT #x-3C300000 #x0)) NIL)
 (< (#.(MAKE-DOUBLE-FLOAT #x43D00000 #x0) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) NIL)
 (< (#.(MAKE-DOUBLE-FLOAT #x43D00000 #x0) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0)) NIL)
@@ -68,6 +74,7 @@
 (<= (#.(MAKE-SINGLE-FLOAT #x-40800000) #.(MAKE-SINGLE-FLOAT #x3DCCCCCD)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-40800000) #.(MAKE-SINGLE-FLOAT #x3F800000)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-32000000) #.(MAKE-SINGLE-FLOAT #x4E000000)) T)
+(<= (#.(MAKE-SINGLE-FLOAT #x-22800000) #.(MAKE-SINGLE-FLOAT #x5D800000)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-21800000) #.(MAKE-SINGLE-FLOAT #x5E800000)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x-40800000)) NIL)
@@ -75,6 +82,7 @@
 (<= (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x3F800000)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x4E000000)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x5883126F)) T)
+(<= (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x5D800000)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x5E800000)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x3D800000) #.(MAKE-SINGLE-FLOAT #x0)) NIL)
 (<= (#.(MAKE-SINGLE-FLOAT #x3DCCCCCD) #.(MAKE-SINGLE-FLOAT #x-40800000)) NIL)
@@ -89,6 +97,7 @@
 (<= (#.(MAKE-SINGLE-FLOAT #x4E6E6B28) #.(MAKE-SINGLE-FLOAT #x40000000)) NIL)
 (<= (#.(MAKE-SINGLE-FLOAT #x5883126F) #.(MAKE-SINGLE-FLOAT #x0)) NIL)
 (<= (#.(MAKE-SINGLE-FLOAT #x5883126F) #.(MAKE-SINGLE-FLOAT #x5883126F)) T)
+(<= (#.(MAKE-SINGLE-FLOAT #x5D800000) #.(MAKE-SINGLE-FLOAT #x5D800000)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x5E7FFFFF) #.(MAKE-SINGLE-FLOAT #x0)) NIL)
 (<= (#.(MAKE-SINGLE-FLOAT #x5E800000) #.(MAKE-SINGLE-FLOAT #x0)) NIL)
 (<= (#.(MAKE-SINGLE-FLOAT #x5E800000) #.(MAKE-SINGLE-FLOAT #x5E800000)) T)
@@ -106,6 +115,7 @@
 (<= (#.(MAKE-DOUBLE-FLOAT #x-3FF6DE05 #x54442D18) #.(MAKE-DOUBLE-FLOAT #x3FF921FB #x54442D18)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-3FF6DE05 #x54442D18) #.(MAKE-DOUBLE-FLOAT #x400921FB #x54442D18)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-3E400000 #x0) #.(MAKE-DOUBLE-FLOAT #x41BFFFFF #xFF000000)) T)
+(<= (#.(MAKE-DOUBLE-FLOAT #x-3C500000 #x0) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-3C300000 #x0) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #x0) T)
@@ -114,6 +124,7 @@
 (<= (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x3FF00000 #x0)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x400921FB #x54442D18)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x41BFFFFF #xFF000000)) T)
+(<= (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x1FFFFF #xFFFFFFFE) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) NIL)
 (<= (#.(MAKE-DOUBLE-FLOAT #x3FB99999 #x9999999A) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) NIL)
@@ -146,6 +157,7 @@
 (<= (#.(MAKE-DOUBLE-FLOAT #x41CDCD65 #x0) #.(MAKE-DOUBLE-FLOAT #x40000000 #x0)) NIL)
 (<= (#.(MAKE-DOUBLE-FLOAT #x4310624D #xD2F1A9F8) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) NIL)
 (<= (#.(MAKE-DOUBLE-FLOAT #x4341C379 #x37E08000) #.(MAKE-DOUBLE-FLOAT #x40000000 #x0)) NIL)
+(<= (#.(MAKE-DOUBLE-FLOAT #x43B00000 #x0) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x43CFFFFF #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) NIL)
 (<= (#.(MAKE-DOUBLE-FLOAT #x43D00000 #x0) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) NIL)
 (<= (#.(MAKE-DOUBLE-FLOAT #x43D00000 #x0) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0)) T)
@@ -156,6 +168,7 @@
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x-40800000) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x-4036F025) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x-32000000) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
+(<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x-22800000) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x-21800000) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x-800000) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) NIL)
@@ -181,6 +194,8 @@
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x4E000000) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x4E6E6B28) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x5883126F) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
+(<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x5D7FFFFF) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
+(<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x5D800000) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x5E7FFFFF) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x5E800000) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
 (<= (#.(MAKE-SINGLE-FLOAT #x-800001) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF) #.(MAKE-SINGLE-FLOAT #x7F7FFFFF)) T)
@@ -190,6 +205,7 @@
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x-4006DE05 #x54442D18) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x-3FF6DE05 #x54442D18) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x-3E400000 #x0) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
+(<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x-3C500000 #x0) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x-3C300000 #x0) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
@@ -218,6 +234,8 @@
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x41CDCD65 #x0) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x4310624D #xD2F1A9F8) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x4341C379 #x37E08000) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
+(<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x43AFFFFF #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
+(<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x43CFFFFF #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
 (<= (#.(MAKE-DOUBLE-FLOAT #x-100001 #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x5FCFFFFF #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) T)
@@ -253,6 +271,8 @@
 (> (#.(MAKE-SINGLE-FLOAT #x-4036F025) #.(MAKE-SINGLE-FLOAT #x3FC90FDB)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x-32000000) #.(MAKE-SINGLE-FLOAT #x-32000000)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x-32000000) #.(MAKE-SINGLE-FLOAT #x4E000000)) NIL)
+(> (#.(MAKE-SINGLE-FLOAT #x-22800000) #.(MAKE-SINGLE-FLOAT #x-22800000)) NIL)
+(> (#.(MAKE-SINGLE-FLOAT #x-22800000) #.(MAKE-SINGLE-FLOAT #x5D800000)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x-21800000) #.(MAKE-SINGLE-FLOAT #x-21800000)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x-21800000) #.(MAKE-SINGLE-FLOAT #x4E000000)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x-21800000) #.(MAKE-SINGLE-FLOAT #x5E800000)) NIL)
@@ -266,6 +286,7 @@
 (> (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x40490FDB)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x4E000000)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x5883126F)) NIL)
+(> (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x5D800000)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x0) #.(MAKE-SINGLE-FLOAT #x5E800000)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x800000) #.(MAKE-SINGLE-FLOAT #x800000)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x3089705F) #.(MAKE-SINGLE-FLOAT #x3089705F)) NIL)
@@ -297,6 +318,8 @@
 (> (#.(MAKE-SINGLE-FLOAT #x4E6E6B28) #.(MAKE-SINGLE-FLOAT #x4E6E6B28)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x5883126F) #.(MAKE-SINGLE-FLOAT #x0)) T)
 (> (#.(MAKE-SINGLE-FLOAT #x5883126F) #.(MAKE-SINGLE-FLOAT #x5883126F)) NIL)
+(> (#.(MAKE-SINGLE-FLOAT #x5D7FFFFF) #.(MAKE-SINGLE-FLOAT #x5D7FFFFF)) NIL)
+(> (#.(MAKE-SINGLE-FLOAT #x5D800000) #.(MAKE-SINGLE-FLOAT #x5D800000)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x5E7FFFFF) #.(MAKE-SINGLE-FLOAT #x5E7FFFFF)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x5E800000) #.(MAKE-SINGLE-FLOAT #x5E800000)) NIL)
 (> (#.(MAKE-SINGLE-FLOAT #x5F000000) #.(MAKE-SINGLE-FLOAT #x5F000000)) NIL)
@@ -314,6 +337,8 @@
 (> (#.(MAKE-DOUBLE-FLOAT #x-3FF6DE05 #x54442D18) #.(MAKE-DOUBLE-FLOAT #x400921FB #x54442D18)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x-3E400000 #x0) #.(MAKE-DOUBLE-FLOAT #x-3E400000 #x0)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x-3E400000 #x0) #.(MAKE-DOUBLE-FLOAT #x41BFFFFF #xFF000000)) NIL)
+(> (#.(MAKE-DOUBLE-FLOAT #x-3C500000 #x0) #.(MAKE-DOUBLE-FLOAT #x-3C500000 #x0)) NIL)
+(> (#.(MAKE-DOUBLE-FLOAT #x-3C500000 #x0) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x-3C300000 #x0) #.(MAKE-DOUBLE-FLOAT #x-3C300000 #x0)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x-3C300000 #x0) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x-3C200000 #x0) #.(MAKE-DOUBLE-FLOAT #x-3C200000 #x0)) NIL)
@@ -328,6 +353,7 @@
 (> (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x400921FB #x54442D18)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x41BFFFFF #xFF000000)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x4310624D #xD2F1A9F8)) NIL)
+(> (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x0 #x0) #.(MAKE-DOUBLE-FLOAT #x7FEFFFFF #xFFFFFFFF)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x100000 #x0) #.(MAKE-DOUBLE-FLOAT #x100000 #x0)) NIL)
@@ -367,6 +393,8 @@
 (> (#.(MAKE-DOUBLE-FLOAT #x4310624D #xD2F1A9F8) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) T)
 (> (#.(MAKE-DOUBLE-FLOAT #x4310624D #xD2F1A9F8) #.(MAKE-DOUBLE-FLOAT #x4310624D #xD2F1A9F8)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x4341C379 #x37E08000) #.(MAKE-DOUBLE-FLOAT #x4341C379 #x37E08000)) NIL)
+(> (#.(MAKE-DOUBLE-FLOAT #x43AFFFFF #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x43AFFFFF #xFFFFFFFF)) NIL)
+(> (#.(MAKE-DOUBLE-FLOAT #x43B00000 #x0) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x43CFFFFF #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x43CFFFFF #xFFFFFFFF)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x43D00000 #x0) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0)) NIL)
 (> (#.(MAKE-DOUBLE-FLOAT #x43E00000 #x0) #.(MAKE-DOUBLE-FLOAT #x43E00000 #x0)) NIL)
@@ -384,6 +412,7 @@
 (>= (#.(MAKE-SINGLE-FLOAT #x-32000000) #.(MAKE-SINGLE-FLOAT #x-80000000)) NIL)
 (>= (#.(MAKE-SINGLE-FLOAT #x-32000000) #.(MAKE-SINGLE-FLOAT #x-32000000)) T)
 (>= (#.(MAKE-SINGLE-FLOAT #x-32000000) #.(MAKE-SINGLE-FLOAT #x0)) NIL)
+(>= (#.(MAKE-SINGLE-FLOAT #x-22800000) #.(MAKE-SINGLE-FLOAT #x-22800000)) T)
 (>= (#.(MAKE-SINGLE-FLOAT #x-21800000) #.(MAKE-SINGLE-FLOAT #x-80000000)) NIL)
 (>= (#.(MAKE-SINGLE-FLOAT #x-21800000) #.(MAKE-SINGLE-FLOAT #x-21800000)) T)
 (>= (#.(MAKE-SINGLE-FLOAT #x-21000000) #.(MAKE-SINGLE-FLOAT #x5F000000)) NIL)
@@ -419,6 +448,7 @@
 (>= (#.(MAKE-SINGLE-FLOAT #x5883126F) #.(MAKE-SINGLE-FLOAT #x-80000000)) T)
 (>= (#.(MAKE-SINGLE-FLOAT #x5883126F) #.(MAKE-SINGLE-FLOAT #x0)) T)
 (>= (#.(MAKE-SINGLE-FLOAT #x5883126F) #.(MAKE-SINGLE-FLOAT #x5883126F)) T)
+(>= (#.(MAKE-SINGLE-FLOAT #x5D800000) #.(MAKE-SINGLE-FLOAT #x5D800000)) T)
 (>= (#.(MAKE-SINGLE-FLOAT #x5E7FFFFF) #.(MAKE-SINGLE-FLOAT #x-80000000)) T)
 (>= (#.(MAKE-SINGLE-FLOAT #x5E800000) #.(MAKE-SINGLE-FLOAT #x-80000000)) T)
 (>= (#.(MAKE-SINGLE-FLOAT #x5E800000) #.(MAKE-SINGLE-FLOAT #x5E800000)) T)
@@ -443,6 +473,7 @@
 (>= (#.(MAKE-DOUBLE-FLOAT #x-3E400000 #x0) #.(MAKE-DOUBLE-FLOAT #x-80000000 #x0)) NIL)
 (>= (#.(MAKE-DOUBLE-FLOAT #x-3E400000 #x0) #.(MAKE-DOUBLE-FLOAT #x-3E400000 #x0)) T)
 (>= (#.(MAKE-DOUBLE-FLOAT #x-3E400000 #x0) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) NIL)
+(>= (#.(MAKE-DOUBLE-FLOAT #x-3C500000 #x0) #.(MAKE-DOUBLE-FLOAT #x-3C500000 #x0)) T)
 (>= (#.(MAKE-DOUBLE-FLOAT #x-3C300000 #x0) #.(MAKE-DOUBLE-FLOAT #x-80000000 #x0)) NIL)
 (>= (#.(MAKE-DOUBLE-FLOAT #x-3C300000 #x0) #.(MAKE-DOUBLE-FLOAT #x-3C300000 #x0)) T)
 (>= (#.(MAKE-DOUBLE-FLOAT #x-3C200000 #x0) #.(MAKE-DOUBLE-FLOAT #x43E00000 #x0)) NIL)
@@ -505,6 +536,7 @@
 (>= (#.(MAKE-DOUBLE-FLOAT #x4310624D #xD2F1A9F8) #.(MAKE-DOUBLE-FLOAT #x-80000000 #x0)) T)
 (>= (#.(MAKE-DOUBLE-FLOAT #x4310624D #xD2F1A9F8) #.(MAKE-DOUBLE-FLOAT #x0 #x0)) T)
 (>= (#.(MAKE-DOUBLE-FLOAT #x4341C379 #x37E08000) #.(MAKE-DOUBLE-FLOAT #x40000000 #x0)) T)
+(>= (#.(MAKE-DOUBLE-FLOAT #x43B00000 #x0) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0)) T)
 (>= (#.(MAKE-DOUBLE-FLOAT #x43CFFFFF #xFFFFFFFF) #.(MAKE-DOUBLE-FLOAT #x-80000000 #x0)) T)
 (>= (#.(MAKE-DOUBLE-FLOAT #x43D00000 #x0) #.(MAKE-DOUBLE-FLOAT #x-80000000 #x0)) T)
 (>= (#.(MAKE-DOUBLE-FLOAT #x43D00000 #x0) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0)) T)
@@ -518,6 +550,8 @@
 (ABS #.(MAKE-DOUBLE-FLOAT #x400921FB #x54442D18) #.(MAKE-DOUBLE-FLOAT #x400921FB #x54442D18))
 (COERCE (#x-4000000000000000 DOUBLE-FLOAT) #.(MAKE-DOUBLE-FLOAT #x-3C300000 #x0))
 (COERCE (#x-4000000000000000 SINGLE-FLOAT) #.(MAKE-SINGLE-FLOAT #x-21800000))
+(COERCE (#x-1000000000000000 DOUBLE-FLOAT) #.(MAKE-DOUBLE-FLOAT #x-3C500000 #x0))
+(COERCE (#x-1000000000000000 SINGLE-FLOAT) #.(MAKE-SINGLE-FLOAT #x-22800000))
 (COERCE (#x-20000000 DOUBLE-FLOAT) #.(MAKE-DOUBLE-FLOAT #x-3E400000 #x0))
 (COERCE (#x-20000000 SINGLE-FLOAT) #.(MAKE-SINGLE-FLOAT #x-32000000))
 (COERCE (#x-1 DOUBLE-FLOAT) #.(MAKE-DOUBLE-FLOAT #x-40100000 #x0))
@@ -539,6 +573,8 @@
 (COERCE (#x1FFFFFFF DOUBLE-FLOAT) #.(MAKE-DOUBLE-FLOAT #x41BFFFFF #xFF000000))
 (COERCE (#x1FFFFFFF SINGLE-FLOAT) #.(MAKE-SINGLE-FLOAT #x4E000000))
 (COERCE (#x4189374BC6A7E LONG-FLOAT) #.(MAKE-DOUBLE-FLOAT #x4310624D #xD2F1A9F8))
+(COERCE (#xFFFFFFFFFFFFFFF DOUBLE-FLOAT) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0))
+(COERCE (#xFFFFFFFFFFFFFFF SINGLE-FLOAT) #.(MAKE-SINGLE-FLOAT #x5D800000))
 (COERCE (#x3FFFFFFFFFFFFFFF DOUBLE-FLOAT) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0))
 (COERCE (#x3FFFFFFFFFFFFFFF SINGLE-FLOAT) #.(MAKE-SINGLE-FLOAT #x5E800000))
 (COERCE (#.(MAKE-SINGLE-FLOAT #x-40800000) DOUBLE-FLOAT) #.(MAKE-DOUBLE-FLOAT #x-40100000 #x0))
@@ -562,6 +598,8 @@
 (FLOAT (#x1FFFFFFF #.(MAKE-SINGLE-FLOAT #x3F800000)) #.(MAKE-SINGLE-FLOAT #x4E000000))
 (FLOAT (#x1FFFFFFF #.(MAKE-DOUBLE-FLOAT #x3FF00000 #x0)) #.(MAKE-DOUBLE-FLOAT #x41BFFFFF #xFF000000))
 (FLOAT (#x4189374BC6A7E #.(MAKE-SINGLE-FLOAT #x3F800000)) #.(MAKE-SINGLE-FLOAT #x5883126F))
+(FLOAT (#xFFFFFFFFFFFFFFF #.(MAKE-SINGLE-FLOAT #x3F800000)) #.(MAKE-SINGLE-FLOAT #x5D800000))
+(FLOAT (#xFFFFFFFFFFFFFFF #.(MAKE-DOUBLE-FLOAT #x3FF00000 #x0)) #.(MAKE-DOUBLE-FLOAT #x43B00000 #x0))
 (FLOAT (#x3FFFFFFFFFFFFFFF #.(MAKE-SINGLE-FLOAT #x3F800000)) #.(MAKE-SINGLE-FLOAT #x5E800000))
 (FLOAT (#x3FFFFFFFFFFFFFFF #.(MAKE-DOUBLE-FLOAT #x3FF00000 #x0)) #.(MAKE-DOUBLE-FLOAT #x43D00000 #x0))
 (FLOAT-SIGN (#.(MAKE-DOUBLE-FLOAT #x0 #x0)) #.(MAKE-DOUBLE-FLOAT #x3FF00000 #x0))

src/assembly/ppc64/tramps.lisp

@@ -111,8 +111,8 @@
     ;; without loading r2. Just r12 is enough, because the callee
     ;; can compute r2 from r12 if it needs to.
     ;; big-endian would more accurately be: if this is the v1 ABI
-    #+big-endian (inst ld r2 r12 8) ; TODO: SEE WHAT HAPPENS IF WE DON'T DO THIS AT ALL
+    #+big-endian (progn (inst ld r2 r12 8) ; TODO: SEE WHAT HAPPENS IF WE DON'T DO THIS AT ALL
-    (inst ld r12 r12 0)
+                        (inst ld r12 r12 0))
     ;; load the size argument into the first C argument register
     (inst ld r3 lip -8)
     (inst mtctr r12)

src/compiler/generic/early-vm.lisp

@@ -31,9 +31,8 @@
   ;; constraint on the high end is that it must not exceed
   ;; WORD-SHIFT (defined below) due to the use of unboxed
   ;; word-aligned byte pointers as boxed values in various
-  ;; places.  FIXME: This should possibly be exposed for
+  ;; places.
-  ;; configuration via customize-target-features.
+  #+64-bit (or #+ppc64 3 #-ppc64 1)
-  #+64-bit 1
   ;; On 32-bit targets, this may be as low as 2 (for 30-bit
   ;; fixnums) and as high as 2 (for 30-bit fixnums).  The
   ;; constraint on the low end is simple overcrowding of the

src/compiler/ppc64/arith.lisp

@@ -561,7 +561,7 @@
 
 (define-vop (fast-conditional-c/fixnum fast-conditional/fixnum)
   (:args (x :scs (any-reg)))
-  (:arg-types tagged-num (:constant (signed-byte 14)))
+  (:arg-types tagged-num (:constant (signed-byte #.(- 16 n-fixnum-tag-bits))))
   (:info target not-p y))
 
 (define-vop (fast-conditional/signed fast-conditional)

src/compiler/ppc64/insts.lisp

@@ -1438,6 +1438,7 @@
 
   (macrolet ((def (mnemonic op Rc)
                `(define-instruction ,mnemonic (segment ra rs sh m)
+                  (:declare (type (integer 0 63) sh m))
                   (:printer md-form ((op 30) (subop ,op) (rc ,rc)))
                   (:emitter
                    (emit-md-form-inst segment 30
@@ -1941,10 +1942,12 @@
     `(inst rlwinm. ,ra ,rs (mod (+ ,b ,n) 32) (- 32 ,n) 31))
 
   (define-instruction-macro srwi (ra rs n) ; N < 32
-    `(inst rlwinm ,ra ,rs (- 32 ,n) ,n 31))
+    `(let ((.n. (the (integer 0 31) ,n)))
+       (inst rlwinm ,ra ,rs (logand #b11111 (- 32 .n.)) .n. 31))) ; n=0 -> rotate 0
 
   (define-instruction-macro srwi. (ra rs n)
-    `(inst rlwinm. ,ra ,rs (- 32 ,n) ,n 31))
+    `(let ((.n. (the (integer 0 31) ,n)))
+       (inst rlwinm. ,ra ,rs (logand #b11111 (- 32 .n.)) .n. 31))) ; n=0 -> rotate 0
 
   (define-instruction-macro clrlwi (ra rs n)
     `(inst rlwinm ,ra ,rs 0 ,n 31))
@@ -1997,10 +2000,12 @@
     `(inst rldicr. ,ra ,rs ,n (- 63 ,n)))
 
   (define-instruction-macro srdi (ra rs n) ; N < 64
-    `(inst rldicl ,ra ,rs (- 64 ,n) ,n))
+    `(let ((.n. (the (integer 0 63) ,n)))
+       (inst rldicl ,ra ,rs (logand #b111111 (- 64 .n.)) .n.))) ; n=0 -> rotate 0
 
   (define-instruction-macro srdi. (ra rs n)
-    `(inst rldicl. ,ra ,rs (- 64 ,n) ,n))
+    `(let ((.n. (the (integer 0 63) ,n)))
+       (inst rldicl. ,ra ,rs (logand #b111111 (- 64 .n.)) .n.))) ; n=0 -> rotate 0
 
   (define-instruction-macro clrrdi (ra rs n) ; N < 64
     `(inst rldicr ,ra ,rs 0 (- 63 ,n)))

src/compiler/ppc64/move.lisp

@@ -173,12 +173,16 @@
   (:temporary (:sc non-descriptor-reg :offset nl3-offset) pa-flag)
   (:note "signed word to integer coercion")
   (:generator 20
-    #.(aver (= n-fixnum-tag-bits 1))
     (move x arg)
     ;; Don't even think about using mcrxr, you couldn't make up a
     ;; slower instruction
     (inst li temp-reg-tn 0) (inst mtxer temp-reg-tn) ; clear XER
-    (inst addo. y arg arg)
+    (ecase n-fixnum-tag-bits
+      (1 (inst addo. y arg arg))
+      ;; result is not properly tagged until all shifts are performed,
+      ;; so don't move result into Y until the last step.
+      (2 (inst addo temp arg arg) (inst addo. y temp temp))
+      (3 (inst addo temp arg arg) (inst addo temp temp temp) (inst addo. y temp temp)))
     (inst bns done) ; branch if no summary overflow
     (with-fixed-allocation (y pa-flag temp bignum-widetag (1+ bignum-digits-offset))
       (storew x y bignum-digits-offset other-pointer-lowtag))
@@ -186,31 +190,40 @@
 (define-move-vop move-from-signed :move
   (signed-reg) (descriptor-reg))
 
-(define-vop (move-from-fixnum+1)
+(macrolet ((define-move-from-fixnum+1 ()
-  (:args (arg :scs (signed-reg unsigned-reg) :target x))
+             `(define-vop (move-from-fixnum+1)
-  (:results (y :scs (any-reg descriptor-reg)))
+                (:args (arg :scs (signed-reg unsigned-reg)
-  (:temporary (:scs (non-descriptor-reg) :from (:argument 0)) x)
+                            ,@(when (> n-fixnum-tag-bits 1)
-  (:vop-var vop)
+                                '(:target x))))
-  (:generator 4
+                ,@(when (> n-fixnum-tag-bits 1)
-    #.(aver (= n-fixnum-tag-bits 1))
+                    '((:temporary (:scs (non-descriptor-reg) :from (:argument 0)) x)))
-    (move x arg)
+                (:results (y :scs (any-reg descriptor-reg)))
-    (inst li temp-reg-tn 0) (inst mtxer temp-reg-tn) ; clear XER
+                (:vop-var vop)
-    (inst addo. y x x)
+                (:generator 4
-    (inst bns done) ; branch if no summary overflow
+                  (inst li temp-reg-tn 0) (inst mtxer temp-reg-tn) ; clear XER
-    (load-constant vop (emit-constant (1+ sb-xc:most-positive-fixnum))
+                  ;; this condition has to be done as part of the macroexpander
-                   y)
+                  ;; because the variable X does not exist for case 1.
-    DONE))
+                  ,@(ecase n-fixnum-tag-bits
+                      (1 '((inst addo. y arg arg)))
+                      (2 '((inst addo x arg arg) (inst addo. y x x)))
+                      (3 '((inst addo x arg arg) (inst addo x x x) (inst addo. y x x))))
+                  (inst bns done) ; branch if no summary overflow
+                  (load-constant vop (emit-constant (1+ sb-xc:most-positive-fixnum)) y)
+                  DONE))))
+  (define-move-from-fixnum+1))
 
-(define-vop (move-from-fixnum-1 move-from-fixnum+1)
+(macrolet ((define-move-from-fixnum-1 ()
-  (:generator 4
+             `(define-vop (move-from-fixnum-1 move-from-fixnum+1)
-    #.(aver (= n-fixnum-tag-bits 1))
+                (:generator 4
-    (move x arg)
+                  (inst li temp-reg-tn 0) (inst mtxer temp-reg-tn) ; clear XER
-    (inst li temp-reg-tn 0) (inst mtxer temp-reg-tn) ; clear XER
+                  ,@(ecase n-fixnum-tag-bits
-    (inst addo. y x x)
+                      (1 '((inst addo. y arg arg)))
-    (inst bns done) ; branch if no summary overflow
+                      (2 '((inst addo x arg arg) (inst addo. y x x)))
-    (load-constant vop (emit-constant (1- sb-xc:most-negative-fixnum))
+                      (3 '((inst addo x arg arg) (inst addo x x x) (inst addo. y x x))))
-                   y)
+                  (inst bns done) ; branch if no summary overflow
-    DONE))
+                  (load-constant vop (emit-constant (1- sb-xc:most-negative-fixnum)) y)
+                  DONE))))
+  (define-move-from-fixnum-1))
 
 ;;; Check for fixnum, and possibly allocate one or two word bignum
 ;;; result.  Use a worst-case cost to make sure people know they may

src/runtime/ppc64-assem.S

@@ -513,13 +513,13 @@ lra:
 	/* Compute the correct value for reg_CODE based on the LRA.
 	This is a "simple" matter of subtracting a constant from
 	reg_LRA (where the LRA is stored by the return sequence) to
-	obtain a tagged pointer to the enclosing code component.  Both
+	obtain a tagged pointer to the enclosing code component.
-	values are tagged OTHER_POINTER_LOWTAG, so we just have to
+	Code pointers have no tag, so we have have to subtract
-	account for N words (see calculation for RETURN_PC_WIDETAG, above)
+	OTHER_POINTER_LOWTAG as well as account for the number of
-	between the two addresses.
+	boxed words (see calculation for RETURN_PC_WIDETAG, above).
 	Restoring reg_CODE doesn't appear to be strictly necessary
 	here, but let's observe the niceties.*/
-	addi reg_CODE, reg_LRA, ((CODE_SIZE+1)&~1)*-N_WORD_BYTES
+	addi reg_CODE, reg_LRA, ((CODE_SIZE+1)&~1)*-N_WORD_BYTES-OTHER_POINTER_LOWTAG
 
 	/* Multiple values are stored relative to reg_OCFP, which we
 	set to be the current top-of-stack. */
@@ -529,7 +529,7 @@ lra:
 	addi reg_CSP, reg_CSP, 4
 
 	/* Record the number of values we have as a FIXNUM. */
-	li reg_NARGS, 4
+	li reg_NARGS, 1<<N_FIXNUM_TAG_BITS
 
 	/* Blank the remaining arg-passing registers. */
 	mr reg_A1, reg_NULL
@@ -542,6 +542,8 @@ lra:
 fun_end_breakpoint_multiple_values:
 	/* Compute the correct value for reg_CODE.  See the
 	explanation for the single-value case, above. */
+	// And of course this is even more magic since we seem to assume
+	// a certain code size. Wtf is this actually supposed to be????
 	addi reg_CODE, reg_LRA, -24
 
 	/* The actual magic trap. */

tests/compiler.impure.lisp

@@ -955,7 +955,7 @@
 
 ;;;; MUFFLE-CONDITIONS test (corresponds to the test in the manual)
 ; FIXME: make a better test!
-(with-test (:name muffle-conditions :skipped-on (or :alpha :x86-64))
+(with-test (:name muffle-conditions :skipped-on (or :alpha :ppc64 :x86-64))
   (multiple-value-bind (fun failure-p warnings style-warnings notes)
       (checked-compile
        '(lambda (x)