Make the 64 bit raster backend an optional feature

Can be used to make smaller binaries, and possibly speed up ARGB32
rendering on some platforms.

Change-Id: I7647b197ba7a6582187cc9736b7e0d752bd5bee5
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

1 files changed, 393 insertions, 309 deletions

diff --git a/src/gui/painting/qcompositionfunctions.cpp b/src/gui/painting/qcompositionfunctions.cpp
index 5c1afe8425..06a849e790 100644
--- a/src/gui/painting/qcompositionfunctions.cpp
+++ b/src/gui/painting/qcompositionfunctions.cpp
@@ -137,6 +137,7 @@ struct Rgba64OperationsBase
     { ::memcpy(dest, src, len * sizeof(Type)); }
 };
 
+#if QT_CONFIG(raster_64bit)
 const Rgba64OperationsBase::Type Rgba64OperationsBase::clear = QRgba64::fromRgba64(0);
 
 struct Rgba64OperationsC : public Rgba64OperationsBase
@@ -309,10 +310,8 @@ struct Rgba64OperationsNEON : public Rgba64OperationsBase
         return interpolate65535(x, a1, y, a2);
     }
 };
-
 #endif
 
-typedef Argb32OperationsC Argb32Operations;
 #if defined(__SSE2__)
 typedef Rgba64OperationsSSE2 Rgba64Operations;
 #elif defined(__ARM_NEON__)
@@ -320,6 +319,9 @@ typedef Rgba64OperationsNEON Rgba64Operations;
 #else
 typedef Rgba64OperationsC Rgba64Operations;
 #endif
+#endif // QT_CONFIG(raster_64bit)
+
+typedef Argb32OperationsC Argb32Operations;
 
 /*
   result = 0
@@ -343,20 +345,23 @@ void QT_FASTCALL comp_func_solid_Clear(uint *dest, int length, uint, uint const_
     comp_func_Clear_template<Argb32Operations>(dest, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_Clear_rgb64(QRgba64 *dest, int length, QRgba64, uint const_alpha)
+void QT_FASTCALL comp_func_Clear(uint *dest, const uint *, int length, uint const_alpha)
 {
-    comp_func_Clear_template<Rgba64Operations>(dest, length, const_alpha);
+    comp_func_Clear_template<Argb32Operations>(dest, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_Clear(uint *dest, const uint *, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_Clear_rgb64(QRgba64 *dest, int length, QRgba64, uint const_alpha)
 {
-    comp_func_Clear_template<Argb32Operations>(dest, length, const_alpha);
+    comp_func_Clear_template<Rgba64Operations>(dest, length, const_alpha);
 }
 
 void QT_FASTCALL comp_func_Clear_rgb64(QRgba64 *dest, const QRgba64 *, int length, uint const_alpha)
 {
     comp_func_Clear_template<Rgba64Operations>(dest, length, const_alpha);
 }
+#endif
+
 
 /*
   result = s
@@ -399,36 +404,40 @@ void QT_FASTCALL comp_func_solid_Source(uint *dest, int length, uint color, uint
     comp_func_solid_Source_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_Source_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_Source(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_Source_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_Source_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_Source(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_Source_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_Source_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_Source_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_Source_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_Source_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 void QT_FASTCALL comp_func_solid_Destination(uint *, int, uint, uint)
 {
 }
 
-void QT_FASTCALL comp_func_solid_Destination_rgb64(QRgba64 *, int, QRgba64, uint)
+void QT_FASTCALL comp_func_Destination(uint *, const uint *, int, uint)
 {
 }
 
-void QT_FASTCALL comp_func_Destination(uint *, const uint *, int, uint)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_Destination_rgb64(QRgba64 *, int, QRgba64, uint)
 {
 }
 
 void QT_FASTCALL comp_func_Destination_rgb64(QRgba64 *, const QRgba64 *, int, uint)
 {
 }
+#endif
 
 /*
   result = s + d * sia
@@ -483,20 +492,22 @@ void QT_FASTCALL comp_func_solid_SourceOver(uint *dest, int length, uint color,
     comp_func_solid_SourceOver_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_SourceOver_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_SourceOver(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_SourceOver_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_SourceOver_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_SourceOver(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_SourceOver_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_SourceOver_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_SourceOver_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_SourceOver_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_SourceOver_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 /*
   result = d + s * dia
@@ -542,20 +553,22 @@ void QT_FASTCALL comp_func_solid_DestinationOver(uint *dest, int length, uint co
     comp_func_solid_DestinationOver_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_DestinationOver_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_DestinationOver(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_DestinationOver_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_DestinationOver_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_DestinationOver(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_DestinationOver_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_DestinationOver_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_DestinationOver_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_DestinationOver_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_DestinationOver_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 /*
   result = s * da
@@ -606,20 +619,22 @@ void QT_FASTCALL comp_func_solid_SourceIn(uint *dest, int length, uint color, ui
     comp_func_solid_SourceIn_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_SourceIn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_SourceIn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_SourceIn_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_SourceIn_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_SourceIn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_SourceIn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_SourceIn_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_SourceIn_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_SourceIn_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_SourceIn_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 /*
   result = d * sa
@@ -665,20 +680,22 @@ void QT_FASTCALL comp_func_solid_DestinationIn(uint *dest, int length, uint colo
     comp_func_solid_DestinationIn_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_DestinationIn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_DestinationIn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_DestinationIn_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_DestinationIn_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_DestinationIn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_DestinationIn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_DestinationIn_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_DestinationIn_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_DestinationIn_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_DestinationIn_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 /*
   result = s * dia
@@ -727,20 +744,22 @@ void QT_FASTCALL comp_func_solid_SourceOut(uint *dest, int length, uint color, u
     comp_func_solid_SourceOut_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_SourceOut_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_SourceOut(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_SourceOut_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_SourceOut_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_SourceOut(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_SourceOut_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_SourceOut_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_SourceOut_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_SourceOut_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_SourceOut_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 /*
   result = d * sia
@@ -786,20 +805,22 @@ void QT_FASTCALL comp_func_solid_DestinationOut(uint *dest, int length, uint col
     comp_func_solid_DestinationOut_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_DestinationOut_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_DestinationOut(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_DestinationOut_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_DestinationOut_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_DestinationOut(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_DestinationOut_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_DestinationOut_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_DestinationOut_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_DestinationOut_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_DestinationOut_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 /*
   result = s*da + d*sia
@@ -845,20 +866,22 @@ void QT_FASTCALL comp_func_solid_SourceAtop(uint *dest, int length, uint color,
     comp_func_solid_SourceAtop_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_SourceAtop_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_SourceAtop(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_SourceAtop_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_SourceAtop_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_SourceAtop(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_SourceAtop_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_SourceAtop_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_SourceAtop_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_SourceAtop_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_SourceAtop_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 /*
   result = d*sa + s*dia
@@ -909,20 +932,22 @@ void QT_FASTCALL comp_func_solid_DestinationAtop(uint *dest, int length, uint co
     comp_func_solid_DestinationAtop_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_DestinationAtop_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_DestinationAtop(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_DestinationAtop_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_DestinationAtop_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_DestinationAtop(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_DestinationAtop_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_DestinationAtop_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_DestinationAtop_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_DestinationAtop_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_DestinationAtop_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 /*
   result = d*sia + s*dia
@@ -969,20 +994,22 @@ void QT_FASTCALL comp_func_solid_XOR(uint *dest, int length, uint color, uint co
     comp_func_solid_XOR_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_XOR_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_XOR(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_XOR_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_XOR_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_XOR(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_XOR_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_XOR_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_XOR_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_XOR_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_XOR_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 struct QFullCoverage {
     inline void store(uint *dest, const uint src) const
@@ -1078,20 +1105,22 @@ void QT_FASTCALL comp_func_solid_Plus(uint *dest, int length, uint color, uint c
     comp_func_solid_Plus_template<Argb32Operations>(dest, length, color, const_alpha);
 }
 
-void QT_FASTCALL comp_func_solid_Plus_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+void QT_FASTCALL comp_func_Plus(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    comp_func_solid_Plus_template<Rgba64Operations>(dest, length, color, const_alpha);
+    comp_func_Plus_template<Argb32Operations>(dest, src, length, const_alpha);
 }
 
-void QT_FASTCALL comp_func_Plus(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_Plus_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
-    comp_func_Plus_template<Argb32Operations>(dest, src, length, const_alpha);
+    comp_func_solid_Plus_template<Rgba64Operations>(dest, length, color, const_alpha);
 }
 
 void QT_FASTCALL comp_func_Plus_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     comp_func_Plus_template<Rgba64Operations>(dest, src, length, const_alpha);
 }
+#endif
 
 /*
     Dca' = Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
@@ -1101,11 +1130,6 @@ static inline int multiply_op(int dst, int src, int da, int sa)
     return qt_div_255(src * dst + src * (255 - da) + dst * (255 - sa));
 }
 
-static inline uint multiply_op_rgb64(uint dst, uint src, uint da, uint sa)
-{
-    return qt_div_65535(src * dst + src * (65535 - da) + dst * (65535 - sa));
-}
-
 template <typename T>
 static inline void comp_func_solid_Multiply_impl(uint *dest, int length, uint color, const T &coverage)
 {
@@ -1129,6 +1153,20 @@ static inline void comp_func_solid_Multiply_impl(uint *dest, int length, uint co
     }
 }
 
+void QT_FASTCALL comp_func_solid_Multiply(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Multiply_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Multiply_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
+static inline uint multiply_op_rgb64(uint dst, uint src, uint da, uint sa)
+{
+    return qt_div_65535(src * dst + src * (65535 - da) + dst * (65535 - sa));
+}
+
 template <typename T>
 static inline void comp_func_solid_Multiply_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -1152,14 +1190,6 @@ static inline void comp_func_solid_Multiply_impl(QRgba64 *dest, int length, QRgb
     }
 }
 
-void QT_FASTCALL comp_func_solid_Multiply(uint *dest, int length, uint color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_Multiply_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_Multiply_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_solid_Multiply_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1167,6 +1197,7 @@ void QT_FASTCALL comp_func_solid_Multiply_rgb64(QRgba64 *dest, int length, QRgba
     else
         comp_func_solid_Multiply_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
+#endif
 
 template <typename T>
 static inline void comp_func_Multiply_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
@@ -1189,6 +1220,15 @@ static inline void comp_func_Multiply_impl(uint *Q_DECL_RESTRICT dest, const uin
     }
 }
 
+void QT_FASTCALL comp_func_Multiply(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Multiply_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Multiply_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_Multiply_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -1210,14 +1250,6 @@ static inline void comp_func_Multiply_impl(QRgba64 *Q_DECL_RESTRICT dest, const
     }
 }
 
-void QT_FASTCALL comp_func_Multiply(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_Multiply_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_Multiply_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_Multiply_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1225,6 +1257,7 @@ void QT_FASTCALL comp_func_Multiply_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const Q
     else
         comp_func_Multiply_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 /*
     Dca' = (Sca.Da + Dca.Sa - Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
@@ -1253,6 +1286,15 @@ static inline void comp_func_solid_Screen_impl(uint *dest, int length, uint colo
     }
 }
 
+void QT_FASTCALL comp_func_solid_Screen(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Screen_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Screen_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_solid_Screen_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -1276,14 +1318,6 @@ static inline void comp_func_solid_Screen_impl(QRgba64 *dest, int length, QRgba6
     }
 }
 
-void QT_FASTCALL comp_func_solid_Screen(uint *dest, int length, uint color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_Screen_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_Screen_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_solid_Screen_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1291,6 +1325,7 @@ void QT_FASTCALL comp_func_solid_Screen_rgb64(QRgba64 *dest, int length, QRgba64
     else
         comp_func_solid_Screen_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
+#endif
 
 template <typename T>
 static inline void comp_func_Screen_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
@@ -1313,6 +1348,15 @@ static inline void comp_func_Screen_impl(uint *Q_DECL_RESTRICT dest, const uint
     }
 }
 
+void QT_FASTCALL comp_func_Screen(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Screen_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Screen_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_Screen_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -1334,14 +1378,6 @@ static inline void comp_func_Screen_impl(QRgba64 *Q_DECL_RESTRICT dest, const QR
     }
 }
 
-void QT_FASTCALL comp_func_Screen(uint *dest, const uint *src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_Screen_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_Screen_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_Screen_rgb64(QRgba64 *dest, const QRgba64 *src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1349,6 +1385,7 @@ void QT_FASTCALL comp_func_Screen_rgb64(QRgba64 *dest, const QRgba64 *src, int l
     else
         comp_func_Screen_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 /*
     if 2.Dca < Da
@@ -1365,15 +1402,6 @@ static inline int overlay_op(int dst, int src, int da, int sa)
         return qt_div_255(sa * da - 2 * (da - dst) * (sa - src) + temp);
 }
 
-static inline uint overlay_op_rgb64(uint dst, uint src, uint da, uint sa)
-{
-    const uint temp = src * (65535 - da) + dst * (65535 - sa);
-    if (2 * dst < da)
-        return qt_div_65535(2 * src * dst + temp);
-    else
-        return qt_div_65535(sa * da - 2 * (da - dst) * (sa - src) + temp);
-}
-
 template <typename T>
 static inline void comp_func_solid_Overlay_impl(uint *dest, int length, uint color, const T &coverage)
 {
@@ -1397,6 +1425,24 @@ static inline void comp_func_solid_Overlay_impl(uint *dest, int length, uint col
     }
 }
 
+void QT_FASTCALL comp_func_solid_Overlay(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Overlay_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Overlay_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
+static inline uint overlay_op_rgb64(uint dst, uint src, uint da, uint sa)
+{
+    const uint temp = src * (65535 - da) + dst * (65535 - sa);
+    if (2 * dst < da)
+        return qt_div_65535(2 * src * dst + temp);
+    else
+        return qt_div_65535(sa * da - 2 * (da - dst) * (sa - src) + temp);
+}
+
 template <typename T>
 static inline void comp_func_solid_Overlay_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -1420,14 +1466,6 @@ static inline void comp_func_solid_Overlay_impl(QRgba64 *dest, int length, QRgba
     }
 }
 
-void QT_FASTCALL comp_func_solid_Overlay(uint *dest, int length, uint color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_Overlay_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_Overlay_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_solid_Overlay_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1435,6 +1473,7 @@ void QT_FASTCALL comp_func_solid_Overlay_rgb64(QRgba64 *dest, int length, QRgba6
     else
         comp_func_solid_Overlay_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
+#endif
 
 template <typename T>
 static inline void comp_func_Overlay_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
@@ -1457,6 +1496,15 @@ static inline void comp_func_Overlay_impl(uint *Q_DECL_RESTRICT dest, const uint
     }
 }
 
+void QT_FASTCALL comp_func_Overlay(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Overlay_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Overlay_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_Overlay_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -1478,14 +1526,6 @@ static inline void comp_func_Overlay_impl(QRgba64 *Q_DECL_RESTRICT dest, const Q
     }
 }
 
-void QT_FASTCALL comp_func_Overlay(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_Overlay_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_Overlay_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_Overlay_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1493,6 +1533,7 @@ void QT_FASTCALL comp_func_Overlay_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QR
     else
         comp_func_Overlay_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 /*
     Dca' = min(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
@@ -1503,11 +1544,6 @@ static inline int darken_op(int dst, int src, int da, int sa)
     return qt_div_255(qMin(src * da, dst * sa) + src * (255 - da) + dst * (255 - sa));
 }
 
-static inline uint darken_op_rgb64(uint dst, uint src, uint da, uint sa)
-{
-    return qt_div_65535(qMin(src * da, dst * sa) + src * (65535 - da) + dst * (65535 - sa));
-}
-
 template <typename T>
 static inline void comp_func_solid_Darken_impl(uint *dest, int length, uint color, const T &coverage)
 {
@@ -1531,6 +1567,20 @@ static inline void comp_func_solid_Darken_impl(uint *dest, int length, uint colo
     }
 }
 
+void QT_FASTCALL comp_func_solid_Darken(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Darken_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Darken_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
+static inline uint darken_op_rgb64(uint dst, uint src, uint da, uint sa)
+{
+    return qt_div_65535(qMin(src * da, dst * sa) + src * (65535 - da) + dst * (65535 - sa));
+}
+
 template <typename T>
 static inline void comp_func_solid_Darken_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -1554,14 +1604,6 @@ static inline void comp_func_solid_Darken_impl(QRgba64 *dest, int length, QRgba6
     }
 }
 
-void QT_FASTCALL comp_func_solid_Darken(uint *dest, int length, uint color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_Darken_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_Darken_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_solid_Darken_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1569,6 +1611,7 @@ void QT_FASTCALL comp_func_solid_Darken_rgb64(QRgba64 *dest, int length, QRgba64
     else
         comp_func_solid_Darken_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
+#endif
 
 template <typename T>
 static inline void comp_func_Darken_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
@@ -1591,6 +1634,15 @@ static inline void comp_func_Darken_impl(uint *Q_DECL_RESTRICT dest, const uint
     }
 }
 
+void QT_FASTCALL comp_func_Darken(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Darken_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Darken_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_Darken_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -1612,14 +1664,6 @@ static inline void comp_func_Darken_impl(QRgba64 *Q_DECL_RESTRICT dest, const QR
     }
 }
 
-void QT_FASTCALL comp_func_Darken(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_Darken_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_Darken_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_Darken_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1627,6 +1671,7 @@ void QT_FASTCALL comp_func_Darken_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRg
     else
         comp_func_Darken_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 /*
    Dca' = max(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
@@ -1637,11 +1682,6 @@ static inline int lighten_op(int dst, int src, int da, int sa)
     return qt_div_255(qMax(src * da, dst * sa) + src * (255 - da) + dst * (255 - sa));
 }
 
-static inline uint lighten_op_rgb64(uint dst, uint src, uint da, uint sa)
-{
-    return qt_div_65535(qMax(src * da, dst * sa) + src * (65535 - da) + dst * (65535 - sa));
-}
-
 template <typename T>
 static inline void comp_func_solid_Lighten_impl(uint *dest, int length, uint color, const T &coverage)
 {
@@ -1665,6 +1705,21 @@ static inline void comp_func_solid_Lighten_impl(uint *dest, int length, uint col
     }
 }
 
+void QT_FASTCALL comp_func_solid_Lighten(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Lighten_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Lighten_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+
+#if QT_CONFIG(raster_64bit)
+static inline uint lighten_op_rgb64(uint dst, uint src, uint da, uint sa)
+{
+    return qt_div_65535(qMax(src * da, dst * sa) + src * (65535 - da) + dst * (65535 - sa));
+}
+
 template <typename T>
 static inline void comp_func_solid_Lighten_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -1688,14 +1743,6 @@ static inline void comp_func_solid_Lighten_impl(QRgba64 *dest, int length, QRgba
     }
 }
 
-void QT_FASTCALL comp_func_solid_Lighten(uint *dest, int length, uint color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_Lighten_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_Lighten_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_solid_Lighten_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1703,6 +1750,7 @@ void QT_FASTCALL comp_func_solid_Lighten_rgb64(QRgba64 *dest, int length, QRgba6
     else
         comp_func_solid_Lighten_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
+#endif
 
 template <typename T>
 static inline void comp_func_Lighten_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
@@ -1725,6 +1773,15 @@ static inline void comp_func_Lighten_impl(uint *Q_DECL_RESTRICT dest, const uint
     }
 }
 
+void QT_FASTCALL comp_func_Lighten(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Lighten_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Lighten_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_Lighten_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -1746,14 +1803,6 @@ static inline void comp_func_Lighten_impl(QRgba64 *Q_DECL_RESTRICT dest, const Q
     }
 }
 
-void QT_FASTCALL comp_func_Lighten(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_Lighten_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_Lighten_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_Lighten_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1761,6 +1810,7 @@ void QT_FASTCALL comp_func_Lighten_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QR
     else
         comp_func_Lighten_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 /*
    if Sca.Da + Dca.Sa >= Sa.Da
@@ -1781,19 +1831,6 @@ static inline int color_dodge_op(int dst, int src, int da, int sa)
         return qt_div_255(255 * dst_sa / (255 - 255 * src / sa) + temp);
 }
 
-static inline uint color_dodge_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
-{
-    const qint64 sa_da = sa * da;
-    const qint64 dst_sa = dst * sa;
-    const qint64 src_da = src * da;
-
-    const qint64 temp = src * (65535 - da) + dst * (65535 - sa);
-    if (src_da + dst_sa >= sa_da)
-        return qt_div_65535(sa_da + temp);
-    else
-        return qt_div_65535(65535 * dst_sa / (65535 - 65535 * src / sa) + temp);
-}
-
 template <typename T>
 static inline void comp_func_solid_ColorDodge_impl(uint *dest, int length, uint color, const T &coverage)
 {
@@ -1817,6 +1854,28 @@ static inline void comp_func_solid_ColorDodge_impl(uint *dest, int length, uint
     }
 }
 
+void QT_FASTCALL comp_func_solid_ColorDodge(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_ColorDodge_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_ColorDodge_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
+static inline uint color_dodge_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
+{
+    const qint64 sa_da = sa * da;
+    const qint64 dst_sa = dst * sa;
+    const qint64 src_da = src * da;
+
+    const qint64 temp = src * (65535 - da) + dst * (65535 - sa);
+    if (src_da + dst_sa >= sa_da)
+        return qt_div_65535(sa_da + temp);
+    else
+        return qt_div_65535(65535 * dst_sa / (65535 - 65535 * src / sa) + temp);
+}
+
 template <typename T>
 static inline void comp_func_solid_ColorDodge_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -1840,14 +1899,6 @@ static inline void comp_func_solid_ColorDodge_impl(QRgba64 *dest, int length, QR
     }
 }
 
-void QT_FASTCALL comp_func_solid_ColorDodge(uint *dest, int length, uint color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_ColorDodge_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_ColorDodge_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_solid_ColorDodge_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1855,6 +1906,7 @@ void QT_FASTCALL comp_func_solid_ColorDodge_rgb64(QRgba64 *dest, int length, QRg
     else
         comp_func_solid_ColorDodge_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
+#endif
 
 template <typename T>
 static inline void comp_func_ColorDodge_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
@@ -1877,6 +1929,15 @@ static inline void comp_func_ColorDodge_impl(uint *Q_DECL_RESTRICT dest, const u
     }
 }
 
+void QT_FASTCALL comp_func_ColorDodge(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_ColorDodge_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_ColorDodge_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_ColorDodge_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -1898,14 +1959,6 @@ static inline void comp_func_ColorDodge_impl(QRgba64 *Q_DECL_RESTRICT dest, cons
     }
 }
 
-void QT_FASTCALL comp_func_ColorDodge(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_ColorDodge_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_ColorDodge_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_ColorDodge_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -1913,6 +1966,7 @@ void QT_FASTCALL comp_func_ColorDodge_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const
     else
         comp_func_ColorDodge_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 /*
    if Sca.Da + Dca.Sa <= Sa.Da
@@ -1933,19 +1987,6 @@ static inline int color_burn_op(int dst, int src, int da, int sa)
     return qt_div_255(sa * (src_da + dst_sa - sa_da) / src + temp);
 }
 
-static inline uint color_burn_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
-{
-    const qint64 src_da = src * da;
-    const qint64 dst_sa = dst * sa;
-    const qint64 sa_da = sa * da;
-
-    const qint64 temp = src * (65535 - da) + dst * (65535 - sa);
-
-    if (src == 0 || src_da + dst_sa <= sa_da)
-        return qt_div_65535(temp);
-    return qt_div_65535(sa * (src_da + dst_sa - sa_da) / src + temp);
-}
-
 template <typename T>
 static inline void comp_func_solid_ColorBurn_impl(uint *dest, int length, uint color, const T &coverage)
 {
@@ -1969,6 +2010,28 @@ static inline void comp_func_solid_ColorBurn_impl(uint *dest, int length, uint c
     }
 }
 
+void QT_FASTCALL comp_func_solid_ColorBurn(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_ColorBurn_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_ColorBurn_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
+static inline uint color_burn_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
+{
+    const qint64 src_da = src * da;
+    const qint64 dst_sa = dst * sa;
+    const qint64 sa_da = sa * da;
+
+    const qint64 temp = src * (65535 - da) + dst * (65535 - sa);
+
+    if (src == 0 || src_da + dst_sa <= sa_da)
+        return qt_div_65535(temp);
+    return qt_div_65535(sa * (src_da + dst_sa - sa_da) / src + temp);
+}
+
 template <typename T>
 static inline void comp_func_solid_ColorBurn_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -1992,14 +2055,6 @@ static inline void comp_func_solid_ColorBurn_impl(QRgba64 *dest, int length, QRg
     }
 }
 
-void QT_FASTCALL comp_func_solid_ColorBurn(uint *dest, int length, uint color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_ColorBurn_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_ColorBurn_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_solid_ColorBurn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -2007,6 +2062,7 @@ void QT_FASTCALL comp_func_solid_ColorBurn_rgb64(QRgba64 *dest, int length, QRgb
     else
         comp_func_solid_ColorBurn_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
+#endif
 
 template <typename T>
 static inline void comp_func_ColorBurn_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
@@ -2029,6 +2085,15 @@ static inline void comp_func_ColorBurn_impl(uint *Q_DECL_RESTRICT dest, const ui
     }
 }
 
+void QT_FASTCALL comp_func_ColorBurn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_ColorBurn_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_ColorBurn_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_ColorBurn_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -2050,14 +2115,6 @@ static inline void comp_func_ColorBurn_impl(QRgba64 *Q_DECL_RESTRICT dest, const
     }
 }
 
-void QT_FASTCALL comp_func_ColorBurn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_ColorBurn_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_ColorBurn_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_ColorBurn_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -2065,6 +2122,7 @@ void QT_FASTCALL comp_func_ColorBurn_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const
     else
         comp_func_ColorBurn_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 /*
     if 2.Sca < Sa
@@ -2082,16 +2140,6 @@ static inline uint hardlight_op(int dst, int src, int da, int sa)
         return qt_div_255(sa * da - 2 * (da - dst) * (sa - src) + temp);
 }
 
-static inline uint hardlight_op_rgb64(uint dst, uint src, uint da, uint sa)
-{
-    const uint temp = src * (65535 - da) + dst * (65535 - sa);
-
-    if (2 * src < sa)
-        return qt_div_65535(2 * src * dst + temp);
-    else
-        return qt_div_65535(sa * da - 2 * (da - dst) * (sa - src) + temp);
-}
-
 template <typename T>
 static inline void comp_func_solid_HardLight_impl(uint *dest, int length, uint color, const T &coverage)
 {
@@ -2115,6 +2163,25 @@ static inline void comp_func_solid_HardLight_impl(uint *dest, int length, uint c
     }
 }
 
+void QT_FASTCALL comp_func_solid_HardLight(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_HardLight_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_HardLight_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
+static inline uint hardlight_op_rgb64(uint dst, uint src, uint da, uint sa)
+{
+    const uint temp = src * (65535 - da) + dst * (65535 - sa);
+
+    if (2 * src < sa)
+        return qt_div_65535(2 * src * dst + temp);
+    else
+        return qt_div_65535(sa * da - 2 * (da - dst) * (sa - src) + temp);
+}
+
 template <typename T>
 static inline void comp_func_solid_HardLight_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -2138,14 +2205,6 @@ static inline void comp_func_solid_HardLight_impl(QRgba64 *dest, int length, QRg
     }
 }
 
-void QT_FASTCALL comp_func_solid_HardLight(uint *dest, int length, uint color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_HardLight_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_HardLight_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_solid_HardLight_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -2153,6 +2212,7 @@ void QT_FASTCALL comp_func_solid_HardLight_rgb64(QRgba64 *dest, int length, QRgb
     else
         comp_func_solid_HardLight_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
+#endif
 
 template <typename T>
 static inline void comp_func_HardLight_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
@@ -2175,6 +2235,15 @@ static inline void comp_func_HardLight_impl(uint *Q_DECL_RESTRICT dest, const ui
     }
 }
 
+void QT_FASTCALL comp_func_HardLight(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_HardLight_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_HardLight_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_HardLight_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -2196,14 +2265,6 @@ static inline void comp_func_HardLight_impl(QRgba64 *Q_DECL_RESTRICT dest, const
     }
 }
 
-void QT_FASTCALL comp_func_HardLight(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_HardLight_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_HardLight_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_HardLight_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -2211,6 +2272,7 @@ void QT_FASTCALL comp_func_HardLight_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const
     else
         comp_func_HardLight_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 /*
     if 2.Sca <= Sa
@@ -2235,22 +2297,6 @@ static inline int soft_light_op(int dst, int src, int da, int sa)
     }
 }
 
-static inline uint soft_light_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
-{
-    const qint64 src2 = src << 1;
-    const qint64 dst_np = da != 0 ? (65535 * dst) / da : 0;
-    const qint64 temp = (src * (65535 - da) + dst * (65535 - sa)) * 65535;
-    const qint64 factor = qint64(65535) * 65535;
-
-    if (src2 < sa)
-        return (dst * (sa * 65535 + (src2 - sa) * (65535 - dst_np)) + temp) / factor;
-    else if (4 * dst <= da)
-        return (dst * sa * 65535 + da * (src2 - sa) * ((((16 * dst_np - 12 * 65535) * dst_np + 3 * factor) * dst_np) / factor) + temp) / factor;
-    else {
-        return (dst * sa * 65535 + da * (src2 - sa) * (int(qSqrt(qreal(dst_np * 65535))) - dst_np) + temp) / factor;
-    }
-}
-
 template <typename T>
 static inline void comp_func_solid_SoftLight_impl(uint *dest, int length, uint color, const T &coverage)
 {
@@ -2274,6 +2320,23 @@ static inline void comp_func_solid_SoftLight_impl(uint *dest, int length, uint c
     }
 }
 
+#if QT_CONFIG(raster_64bit)
+static inline uint soft_light_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
+{
+    const qint64 src2 = src << 1;
+    const qint64 dst_np = da != 0 ? (65535 * dst) / da : 0;
+    const qint64 temp = (src * (65535 - da) + dst * (65535 - sa)) * 65535;
+    const qint64 factor = qint64(65535) * 65535;
+
+    if (src2 < sa)
+        return (dst * (sa * 65535 + (src2 - sa) * (65535 - dst_np)) + temp) / factor;
+    else if (4 * dst <= da)
+        return (dst * sa * 65535 + da * (src2 - sa) * ((((16 * dst_np - 12 * 65535) * dst_np + 3 * factor) * dst_np) / factor) + temp) / factor;
+    else {
+        return (dst * sa * 65535 + da * (src2 - sa) * (int(qSqrt(qreal(dst_np * 65535))) - dst_np) + temp) / factor;
+    }
+}
+
 template <typename T>
 static inline void comp_func_solid_SoftLight_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -2296,6 +2359,7 @@ static inline void comp_func_solid_SoftLight_impl(QRgba64 *dest, int length, QRg
         coverage.store(&dest[i], qRgba64(r, g, b, a));
     }
 }
+#endif
 
 void QT_FASTCALL comp_func_solid_SoftLight(uint *dest, int length, uint color, uint const_alpha)
 {
@@ -2305,14 +2369,6 @@ void QT_FASTCALL comp_func_solid_SoftLight(uint *dest, int length, uint color, u
         comp_func_solid_SoftLight_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
 
-void QT_FASTCALL comp_func_solid_SoftLight_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_SoftLight_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_SoftLight_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 template <typename T>
 static inline void comp_func_SoftLight_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -2334,6 +2390,23 @@ static inline void comp_func_SoftLight_impl(uint *Q_DECL_RESTRICT dest, const ui
     }
 }
 
+void QT_FASTCALL comp_func_SoftLight(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_SoftLight_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_SoftLight_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
+void QT_FASTCALL comp_func_solid_SoftLight_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_SoftLight_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_SoftLight_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
 template <typename T>
 static inline void comp_func_SoftLight_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -2355,14 +2428,6 @@ static inline void comp_func_SoftLight_impl(QRgba64 *Q_DECL_RESTRICT dest, const
     }
 }
 
-void QT_FASTCALL comp_func_SoftLight(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_SoftLight_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_SoftLight_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_SoftLight_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -2370,6 +2435,7 @@ void QT_FASTCALL comp_func_SoftLight_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const
     else
         comp_func_SoftLight_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 /*
    Dca' = abs(Dca.Sa - Sca.Da) + Sca.(1 - Da) + Dca.(1 - Sa)
@@ -2380,11 +2446,6 @@ static inline int difference_op(int dst, int src, int da, int sa)
     return src + dst - qt_div_255(2 * qMin(src * da, dst * sa));
 }
 
-static inline uint difference_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
-{
-    return src + dst - qt_div_65535(2 * qMin(src * da, dst * sa));
-}
-
 template <typename T>
 static inline void comp_func_solid_Difference_impl(uint *dest, int length, uint color, const T &coverage)
 {
@@ -2408,6 +2469,20 @@ static inline void comp_func_solid_Difference_impl(uint *dest, int length, uint
     }
 }
 
+void QT_FASTCALL comp_func_solid_Difference(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Difference_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Difference_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
+static inline uint difference_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
+{
+    return src + dst - qt_div_65535(2 * qMin(src * da, dst * sa));
+}
+
 template <typename T>
 static inline void comp_func_solid_Difference_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -2431,14 +2506,6 @@ static inline void comp_func_solid_Difference_impl(QRgba64 *dest, int length, QR
     }
 }
 
-void QT_FASTCALL comp_func_solid_Difference(uint *dest, int length, uint color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_Difference_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_Difference_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_solid_Difference_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -2446,6 +2513,7 @@ void QT_FASTCALL comp_func_solid_Difference_rgb64(QRgba64 *dest, int length, QRg
     else
         comp_func_solid_Difference_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
+#endif
 
 template <typename T>
 static inline void comp_func_Difference_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
@@ -2468,6 +2536,15 @@ static inline void comp_func_Difference_impl(uint *Q_DECL_RESTRICT dest, const u
     }
 }
 
+void QT_FASTCALL comp_func_Difference(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Difference_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Difference_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_Difference_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -2489,14 +2566,6 @@ static inline void comp_func_Difference_impl(QRgba64 *Q_DECL_RESTRICT dest, cons
     }
 }
 
-void QT_FASTCALL comp_func_Difference(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_Difference_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_Difference_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_Difference_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -2504,6 +2573,7 @@ void QT_FASTCALL comp_func_Difference_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const
     else
         comp_func_Difference_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 /*
     Dca' = (Sca.Da + Dca.Sa - 2.Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
@@ -2531,6 +2601,15 @@ static inline void QT_FASTCALL comp_func_solid_Exclusion_impl(uint *dest, int le
     }
 }
 
+void QT_FASTCALL comp_func_solid_Exclusion(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Exclusion_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Exclusion_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void QT_FASTCALL comp_func_solid_Exclusion_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
 {
@@ -2555,14 +2634,6 @@ static inline void QT_FASTCALL comp_func_solid_Exclusion_impl(QRgba64 *dest, int
 }
 
 
-void QT_FASTCALL comp_func_solid_Exclusion(uint *dest, int length, uint color, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_solid_Exclusion_impl(dest, length, color, QFullCoverage());
-    else
-        comp_func_solid_Exclusion_impl(dest, length, color, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_solid_Exclusion_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -2570,6 +2641,7 @@ void QT_FASTCALL comp_func_solid_Exclusion_rgb64(QRgba64 *dest, int length, QRgb
     else
         comp_func_solid_Exclusion_impl(dest, length, color, QPartialCoverage(const_alpha));
 }
+#endif
 
 template <typename T>
 static inline void comp_func_Exclusion_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
@@ -2592,6 +2664,15 @@ static inline void comp_func_Exclusion_impl(uint *Q_DECL_RESTRICT dest, const ui
     }
 }
 
+void QT_FASTCALL comp_func_Exclusion(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Exclusion_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Exclusion_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if QT_CONFIG(raster_64bit)
 template <typename T>
 static inline void comp_func_Exclusion_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
@@ -2613,14 +2694,6 @@ static inline void comp_func_Exclusion_impl(QRgba64 *Q_DECL_RESTRICT dest, const
     }
 }
 
-void QT_FASTCALL comp_func_Exclusion(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
-{
-    if (const_alpha == 255)
-        comp_func_Exclusion_impl(dest, src, length, QFullCoverage());
-    else
-        comp_func_Exclusion_impl(dest, src, length, QPartialCoverage(const_alpha));
-}
-
 void QT_FASTCALL comp_func_Exclusion_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
@@ -2628,6 +2701,7 @@ void QT_FASTCALL comp_func_Exclusion_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const
     else
         comp_func_Exclusion_impl(dest, src, length, QPartialCoverage(const_alpha));
 }
+#endif
 
 void QT_FASTCALL rasterop_solid_SourceOrDestination(uint *dest,
                                                     int length,
@@ -2977,6 +3051,7 @@ CompositionFunctionSolid qt_functionForModeSolid_C[] = {
 };
 
 CompositionFunctionSolid64 qt_functionForModeSolid64_C[] = {
+#if QT_CONFIG(raster_64bit)
         comp_func_solid_SourceOver_rgb64,
         comp_func_solid_DestinationOver_rgb64,
         comp_func_solid_Clear_rgb64,
@@ -3001,6 +3076,10 @@ CompositionFunctionSolid64 qt_functionForModeSolid64_C[] = {
         comp_func_solid_SoftLight_rgb64,
         comp_func_solid_Difference_rgb64,
         comp_func_solid_Exclusion_rgb64,
+#else
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+#endif
         0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0
 };
@@ -3047,6 +3126,7 @@ CompositionFunction qt_functionForMode_C[] = {
 };
 
 CompositionFunction64 qt_functionForMode64_C[] = {
+#if QT_CONFIG(raster_64bit)
         comp_func_SourceOver_rgb64,
         comp_func_DestinationOver_rgb64,
         comp_func_Clear_rgb64,
@@ -3071,6 +3151,10 @@ CompositionFunction64 qt_functionForMode64_C[] = {
         comp_func_SoftLight_rgb64,
         comp_func_Difference_rgb64,
         comp_func_Exclusion_rgb64,
+#else
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+#endif
         0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0
 };