ARMV6 optimizations to qdrawhelper

6 files changed, 1251 insertions, 18 deletions

diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
index 8f1d762..33d53e4 100644
--- a/src/gui/painting/painting.pri
+++ b/src/gui/painting/painting.pri
@@ -377,5 +377,15 @@ win32:contains(QT_CONFIG, direct3d) {
 symbian {
         HEADERS += painting/qwindowsurface_s60_p.h
         SOURCES += painting/qwindowsurface_s60.cpp
+        armccIfdefBlock = \
+        "$${LITERAL_HASH}if defined(ARMV6)" \
+        "MACRO QT_HAVE_ARMV6" \
+        "SOURCEPATH 	painting" \
+        "SOURCE			qblendfunctions_armv6_rvct.s" \
+        "SOURCE			qdrawhelper_armv6_rvct.s" \
+        "$${LITERAL_HASH}endif"
+                
+        MMP_RULES += armccIfdefBlock
+        QMAKE_CXXFLAGS.ARMCC *= -O3
 }
 
diff --git a/src/gui/painting/qblendfunctions_armv6_rvct.s b/src/gui/painting/qblendfunctions_armv6_rvct.s
new file mode 100644
index 0000000..312bd07
--- /dev/null
+++ b/src/gui/painting/qblendfunctions_armv6_rvct.s
@@ -0,0 +1,223 @@
+;/****************************************************************************
+;**
+;** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+;** Contact: Qt Software Information (qt-info@nokia.com)
+;**
+;** This file is part of the QtGui module of the Qt Toolkit.
+;**
+;** $QT_BEGIN_LICENSE:LGPL$
+;** No Commercial Usage
+;** This file contains pre-release code and may not be distributed.
+;** You may use this file in accordance with the terms and conditions
+;** contained in the either Technology Preview License Agreement or the
+;** Beta Release License Agreement.
+;**
+;** GNU Lesser General Public License Usage
+;** Alternatively, this file may be used under the terms of the GNU Lesser
+;** General Public License version 2.1 as published by the Free Software
+;** Foundation and appearing in the file LICENSE.LGPL included in the
+;** packaging of this file.  Please review the following information to
+;** ensure the GNU Lesser General Public License version 2.1 requirements
+;** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+;**
+;** In addition, as a special exception, Nokia gives you certain
+;** additional rights. These rights are described in the Nokia Qt LGPL
+;** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+;** package.
+;**
+;** GNU General Public License Usage
+;** Alternatively, this file may be used under the terms of the GNU
+;** General Public License version 3.0 as published by the Free Software
+;** Foundation and appearing in the file LICENSE.GPL included in the
+;** packaging of this file.  Please review the following information to
+;** ensure the GNU General Public License version 3.0 requirements will be
+;** met: http://www.gnu.org/copyleft/gpl.html.
+;**
+;** If you are unsure which license is appropriate for your use, please
+;** contact the sales department at qt-sales@nokia.com.
+;** $QT_END_LICENSE$
+;**
+;****************************************************************************/
+
+;
+;  W A R N I N G
+;  -------------
+;
+; This file is not part of the Qt API.  It exists purely as an
+; implementation detail.  This header file may change from version to
+; version without notice, or even be removed.
+;
+; We mean it.
+;
+
+
+		ARM
+		PRESERVE8
+
+		INCLUDE		qdrawhelper_armv6_rvct.inc	
+
+
+;-----------------------------------------------------------------------------
+; qt_blend_rgb32_on_rgb32_arm
+; 
+; @brief 
+;
+; @param dest			Destination	pixels						(r0)
+; @param dbpl			Destination bytes per line				(r1)
+; @param src			Source pixels							(r2)
+; @param sbpl			Source bytes per line					(r3)
+; @param w				Width							  (s0 -> r4)
+; @param h				Height							  (s1 -> r5)
+; @param const_alpha	Constant alpha					  (s2 -> r6)
+; 
+;---------------------------------------------------------------------------
+qt_blend_rgb32_on_rgb32_armv6 Function
+		stmfd	sp!, {r4-r12, r14}
+		
+		; read arguments off the stack
+		add		r8, sp, #10 * 4
+		ldmia	r8, {r9-r11}
+		
+		; Reorganize registers
+		
+		mov		r4, r10
+		mov		r5, r1
+		mov		r6, r3
+		
+		mov		r1, r2
+		mov		r2, r9
+		mov		r3, r11
+		
+		; Now we have registers
+		; @param dest			Destination	pixels						(r0)
+		; @param src			Source pixels							(r1)
+		; @param w				Width							  		(r2)
+		; @param const_alpha	Constant alpha					  		(r3)
+		; @param h				Height							  		(r4)
+		; @param dbpl			Destination bytes per line				(r5)
+		; @param sbpl			Source bytes per line					(r6)
+		
+		cmp		r3, #256 ; test if we have fully opaque constant alpha value
+		bne		rgb32_blend_const_alpha ; branch if not
+		
+rgb32_blend_loop
+
+		subs	r4, r4, #1
+		bmi		rgb32_blend_exit	; while(h--)
+		
+rgb321	PixCpySafe r0, r1, r2		
+
+		add		r0, r0, r5 ; dest = dest + dbpl
+		add		r1, r1, r6 ; src = src + sbpl		
+
+		b		rgb32_blend_loop	
+		
+		
+rgb32_blend_const_alpha
+
+		;ldr		r14, =ComponentHalf ; load 0x800080 to r14
+		mov		r14, #0x800000
+		add		r14, r14, #0x80
+		
+		sub		r3, r3, #1	; const_alpha -= 1;
+
+rgb32_blend_loop_const_alpha
+
+		subs	r4, r4, #1
+		bmi		rgb32_blend_exit	; while(h--)
+		
+rgb322	BlendRowSafe PixelSourceOverConstAlpha
+
+		add		r0, r0, r5 ; dest = dest + dbpl
+		add		r1, r1, r6 ; src = src + sbpl		
+
+		b		rgb32_blend_loop_const_alpha
+		
+rgb32_blend_exit		
+		
+		ldmfd	sp!, {r4-r12, pc}		; pop and return
+	
+	
+	
+;-----------------------------------------------------------------------------
+; qt_blend_argb32_on_argb32_arm
+; 
+; @brief 
+;
+; @param dest			Destination	pixels						(r0)
+; @param dbpl			Destination bytes per line				(r1)
+; @param src			Source pixels							(r2)
+; @param sbpl			Source bytes per line					(r3)
+; @param w				Width							  (s0 -> r4)
+; @param h				Height							  (s1 -> r5)
+; @param const_alpha	Constant alpha					  (s2 -> r6)
+; 
+;---------------------------------------------------------------------------
+qt_blend_argb32_on_argb32_armv6 Function
+		stmfd	sp!, {r4-r12, r14}
+		
+	 	; read arguments off the stack
+		add		r8, sp, #10 * 4
+		ldmia	r8, {r9-r11}
+		
+		; Reorganize registers
+		
+		mov		r4, r10
+		mov		r5, r1
+		mov		r6, r3
+		
+		mov		r1, r2
+		mov		r2, r9
+		mov		r3, r11
+		
+		; Now we have registers
+		; @param dest			Destination	pixels						(r0)
+		; @param src			Source pixels							(r1)
+		; @param w				Width							  		(r2)
+		; @param const_alpha	Constant alpha					  		(r3)
+		; @param h				Height							  		(r4)
+		; @param dbpl			Destination bytes per line				(r5)
+		; @param sbpl			Source bytes per line					(r6)
+		
+		;ldr		r14, =ComponentHalf ; load 0x800080 to r14
+		mov		r14, #0x800000
+		add		r14, r14, #0x80
+		
+		cmp		r3, #256 ; test if we have fully opaque constant alpha value
+		bne		argb32_blend_const_alpha ; branch if not
+		
+argb32_blend_loop
+
+		subs	r4, r4, #1
+		bmi		argb32_blend_exit	; while(h--)
+
+argb321	 BlendRowSafe PixelSourceOver
+
+		add		r0, r0, r5 ; dest = dest + dbpl
+		add		r1, r1, r6 ; src = src + sbpl	
+
+		b		argb32_blend_loop
+		
+argb32_blend_const_alpha
+
+		sub		r3, r3, #1	; const_alpha -= 1;
+
+argb32_blend_loop_const_alpha
+
+		subs	r4, r4, #1
+		bmi		argb32_blend_exit	; while(h--)
+		
+argb322	 BlendRowSafe PixelSourceOverConstAlpha
+
+		add		r0, r0, r5 ; dest = dest + dbpl
+		add		r1, r1, r6 ; src = src + sbpl		
+
+		b		argb32_blend_loop_const_alpha
+		
+argb32_blend_exit		
+		
+		ldmfd	sp!, {r4-r12, pc}		; pop and return
+		
+		
+		END ; File end
+		
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index b8babd7..36e4300 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -38,15 +38,18 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
+
 #include <private/qdrawhelper_p.h>
 #include <private/qpaintengine_raster_p.h>
 #include <private/qpainter_p.h>
 #include <private/qdrawhelper_x86_p.h>
+#include <private/qdrawhelper_armv6_p.h>
 #include <private/qmath_p.h>
 #include <qmath.h>
 
 QT_BEGIN_NAMESPACE
 
+
 #define MASK(src, a) src = BYTE_MUL(src, a)
 
 #if defined(Q_OS_IRIX) && defined(Q_CC_GNU) && __GNUC__ == 3 && __GNUC__ < 4 && QT_POINTER_SIZE == 8
@@ -1497,12 +1500,34 @@ static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operato
     return b;
 }
 
-
-
 #if defined(Q_CC_RVCT)
-// Force ARM code generation for blend methods
+// Force ARM code generation for comp_func_* -methods
 #  pragma push
 #  pragma arm
+#  if defined(QT_HAVE_ARMV6)
+static __forceinline void preload(const uint *start)
+{
+    asm( "pld [start]" );
+}
+static const uint L2CacheLineLength = 32;
+static const uint L2CacheLineLengthInInts = L2CacheLineLength/sizeof(uint);
+#    define PRELOAD_INIT(x) preload(x);
+#    define PRELOAD_INIT2(x,y) PRELOAD_INIT(x) PRELOAD_INIT(y)
+#    define PRELOAD_COND(x) if (((uint)&x[i])%L2CacheLineLength == 0) preload(&x[i] + L2CacheLineLengthInInts);
+// Two consecutive preloads stall, so space them out a bit by using different modulus.
+#    define PRELOAD_COND2(x,y) if (((uint)&x[i])%L2CacheLineLength == 0) preload(&x[i] + L2CacheLineLengthInInts); \
+         if (((uint)&y[i])%L2CacheLineLength == 16) preload(&y[i] + L2CacheLineLengthInInts);
+#  else
+#    define PRELOAD_INIT(x)
+#    define PRELOAD_INIT2(x,y)
+#    define PRELOAD_COND(x)
+#    define PRELOAD_COND2(x,y)
+#  endif
+#else
+#  define PRELOAD_INIT(x)
+#  define PRELOAD_INIT2(x,y)
+#  define PRELOAD_COND(x)
+#  define PRELOAD_COND2(x,y)
 #endif
 
 /* The constant alpha factor describes an alpha factor that gets applied
@@ -1536,8 +1561,11 @@ static void QT_FASTCALL comp_func_solid_Clear(uint *dest, int length, uint, uint
         QT_MEMFILL_UINT(dest, length, 0);
     } else {
         int ialpha = 255 - const_alpha;
-        for (int i = 0; i < length; ++i)
+        PRELOAD_INIT(dest)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
             dest[i] = BYTE_MUL(dest[i], ialpha);
+        }
     }
 }
 
@@ -1547,8 +1575,11 @@ static void QT_FASTCALL comp_func_Clear(uint *dest, const uint *, int length, ui
         QT_MEMFILL_UINT(dest, length, 0);
     } else {
         int ialpha = 255 - const_alpha;
-        for (int i = 0; i < length; ++i)
+        PRELOAD_INIT(dest)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
             dest[i] = BYTE_MUL(dest[i], ialpha);
+        }
     }
 }
 
@@ -1563,8 +1594,11 @@ static void QT_FASTCALL comp_func_solid_Source(uint *dest, int length, uint colo
     } else {
         int ialpha = 255 - const_alpha;
         color = BYTE_MUL(color, const_alpha);
-        for (int i = 0; i < length; ++i)
+        PRELOAD_INIT(dest)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
             dest[i] = color + BYTE_MUL(dest[i], ialpha);
+        }
     }
 }
 
@@ -1574,8 +1608,11 @@ static void QT_FASTCALL comp_func_Source(uint *dest, const uint *src, int length
         ::memcpy(dest, src, length * sizeof(uint));
     } else {
         int ialpha = 255 - const_alpha;
-        for (int i = 0; i < length; ++i)
+        PRELOAD_INIT2(dest, src)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             dest[i] = INTERPOLATE_PIXEL_255(src[i], const_alpha, dest[i], ialpha);
+        }
     }
 }
 
@@ -1600,20 +1637,26 @@ static void QT_FASTCALL comp_func_solid_SourceOver(uint *dest, int length, uint
     } else {
         if (const_alpha != 255)
             color = BYTE_MUL(color, const_alpha);
-        for (int i = 0; i < length; ++i)
+        PRELOAD_INIT(dest)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
             dest[i] = color + BYTE_MUL(dest[i], qAlpha(~color));
+        }
     }
 }
 
 static void QT_FASTCALL comp_func_SourceOver(uint *dest, const uint *src, int length, uint const_alpha)
 {
+    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint s = src[i];
             dest[i] = s + BYTE_MUL(dest[i], qAlpha(~s));
         }
     } else {
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint s = BYTE_MUL(src[i], const_alpha);
             dest[i] = s + BYTE_MUL(dest[i], qAlpha(~s));
         }
@@ -1629,7 +1672,9 @@ static void QT_FASTCALL comp_func_solid_DestinationOver(uint *dest, int length,
 {
     if (const_alpha != 255)
         color = BYTE_MUL(color, const_alpha);
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         dest[i] = d + BYTE_MUL(color, qAlpha(~d));
     }
@@ -1637,13 +1682,16 @@ static void QT_FASTCALL comp_func_solid_DestinationOver(uint *dest, int length,
 
 static void QT_FASTCALL comp_func_DestinationOver(uint *dest, const uint *src, int length, uint const_alpha)
 {
+    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint d = dest[i];
             dest[i] = d + BYTE_MUL(src[i], qAlpha(~d));
         }
     } else {
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint d = dest[i];
             uint s = BYTE_MUL(src[i], const_alpha);
             dest[i] = d + BYTE_MUL(s, qAlpha(~d));
@@ -1657,13 +1705,17 @@ static void QT_FASTCALL comp_func_DestinationOver(uint *dest, const uint *src, i
 */
 static void QT_FASTCALL comp_func_solid_SourceIn(uint *dest, int length, uint color, uint const_alpha)
 {
+    PRELOAD_INIT(dest)
     if (const_alpha == 255) {
-        for (int i = 0; i < length; ++i)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
             dest[i] = BYTE_MUL(color, qAlpha(dest[i]));
+        }
     } else {
         color = BYTE_MUL(color, const_alpha);
         uint cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(d), d, cia);
         }
@@ -1672,12 +1724,16 @@ static void QT_FASTCALL comp_func_solid_SourceIn(uint *dest, int length, uint co
 
 static void QT_FASTCALL comp_func_SourceIn(uint *dest, const uint *src, int length, uint const_alpha)
 {
+    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
-        for (int i = 0; i < length; ++i)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             dest[i] = BYTE_MUL(src[i], qAlpha(dest[i]));
+        }
     } else {
         uint cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint d = dest[i];
             uint s = BYTE_MUL(src[i], const_alpha);
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, cia);
@@ -1696,19 +1752,25 @@ static void QT_FASTCALL comp_func_solid_DestinationIn(uint *dest, int length, ui
     if (const_alpha != 255) {
         a = BYTE_MUL(a, const_alpha) + 255 - const_alpha;
     }
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         dest[i] = BYTE_MUL(dest[i], a);
     }
 }
 
 static void QT_FASTCALL comp_func_DestinationIn(uint *dest, const uint *src, int length, uint const_alpha)
 {
+    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
-        for (int i = 0; i < length; ++i)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             dest[i] = BYTE_MUL(dest[i], qAlpha(src[i]));
+        }
     } else {
         int cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint a = BYTE_MUL(qAlpha(src[i]), const_alpha) + cia;
             dest[i] = BYTE_MUL(dest[i], a);
         }
@@ -1722,13 +1784,17 @@ static void QT_FASTCALL comp_func_DestinationIn(uint *dest, const uint *src, int
 
 static void QT_FASTCALL comp_func_solid_SourceOut(uint *dest, int length, uint color, uint const_alpha)
 {
+    PRELOAD_INIT(dest)
     if (const_alpha == 255) {
-        for (int i = 0; i < length; ++i)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
             dest[i] = BYTE_MUL(color, qAlpha(~dest[i]));
+        }
     } else {
         color = BYTE_MUL(color, const_alpha);
         int cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(~d), d, cia);
         }
@@ -1737,12 +1803,16 @@ static void QT_FASTCALL comp_func_solid_SourceOut(uint *dest, int length, uint c
 
 static void QT_FASTCALL comp_func_SourceOut(uint *dest, const uint *src, int length, uint const_alpha)
 {
+    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
-        for (int i = 0; i < length; ++i)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             dest[i] = BYTE_MUL(src[i], qAlpha(~dest[i]));
+        }
     } else {
         int cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint s = BYTE_MUL(src[i], const_alpha);
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, cia);
@@ -1760,18 +1830,25 @@ static void QT_FASTCALL comp_func_solid_DestinationOut(uint *dest, int length, u
     uint a = qAlpha(~color);
     if (const_alpha != 255)
         a = BYTE_MUL(a, const_alpha) + 255 - const_alpha;
-    for (int i = 0; i < length; ++i)
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         dest[i] = BYTE_MUL(dest[i], a);
+    }
 }
 
 static void QT_FASTCALL comp_func_DestinationOut(uint *dest, const uint *src, int length, uint const_alpha)
 {
+    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
-        for (int i = 0; i < length; ++i)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             dest[i] = BYTE_MUL(dest[i], qAlpha(~src[i]));
+        }
     } else {
         int cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint sia = BYTE_MUL(qAlpha(~src[i]), const_alpha) + cia;
             dest[i] = BYTE_MUL(dest[i], sia);
         }
@@ -1790,20 +1867,26 @@ static void QT_FASTCALL comp_func_solid_SourceAtop(uint *dest, int length, uint
         color = BYTE_MUL(color, const_alpha);
     }
     uint sia = qAlpha(~color);
-    for (int i = 0; i < length; ++i)
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(dest[i]), dest[i], sia);
+    }
 }
 
 static void QT_FASTCALL comp_func_SourceAtop(uint *dest, const uint *src, int length, uint const_alpha)
 {
+    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint s = src[i];
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, qAlpha(~s));
         }
     } else {
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint s = BYTE_MUL(src[i], const_alpha);
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, qAlpha(~s));
@@ -1823,7 +1906,9 @@ static void QT_FASTCALL comp_func_solid_DestinationAtop(uint *dest, int length,
         color = BYTE_MUL(color, const_alpha);
         a = qAlpha(color) + 255 - const_alpha;
     }
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         dest[i] = INTERPOLATE_PIXEL_255(d, a, color, qAlpha(~d));
     }
@@ -1831,8 +1916,10 @@ static void QT_FASTCALL comp_func_solid_DestinationAtop(uint *dest, int length,
 
 static void QT_FASTCALL comp_func_DestinationAtop(uint *dest, const uint *src, int length, uint const_alpha)
 {
+    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint s = src[i];
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(d, qAlpha(s), s, qAlpha(~d));
@@ -1840,6 +1927,7 @@ static void QT_FASTCALL comp_func_DestinationAtop(uint *dest, const uint *src, i
     } else {
         int cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint s = BYTE_MUL(src[i], const_alpha);
             uint d = dest[i];
             uint a = qAlpha(s) + cia;
@@ -1860,7 +1948,9 @@ static void QT_FASTCALL comp_func_solid_XOR(uint *dest, int length, uint color,
         color = BYTE_MUL(color, const_alpha);
     uint sia = qAlpha(~color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(~d), d, sia);
     }
@@ -1868,14 +1958,17 @@ static void QT_FASTCALL comp_func_solid_XOR(uint *dest, int length, uint color,
 
 static void QT_FASTCALL comp_func_XOR(uint *dest, const uint *src, int length, uint const_alpha)
 {
+    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint d = dest[i];
             uint s = src[i];
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, qAlpha(~s));
         }
     } else {
         for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
             uint d = dest[i];
             uint s = BYTE_MUL(src[i], const_alpha);
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, qAlpha(~s));
@@ -1926,7 +2019,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Plus_impl(uint *dest, int
 {
     uint s = color;
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
 #define MIX(mask) (qMin(((qint64(s)&mask) + (qint64(d)&mask)), qint64(mask)))
         d = (MIX(AMASK) | MIX(RMASK) | MIX(GMASK) | MIX(BMASK));
@@ -1946,7 +2041,9 @@ static void QT_FASTCALL comp_func_solid_Plus(uint *dest, int length, uint color,
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Plus_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -1982,7 +2079,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Multiply_impl(uint *dest,
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2008,7 +2107,9 @@ static void QT_FASTCALL comp_func_solid_Multiply(uint *dest, int length, uint co
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Multiply_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2046,7 +2147,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Screen_impl(uint *dest, i
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2072,7 +2175,9 @@ static void QT_FASTCALL comp_func_solid_Screen(uint *dest, int length, uint colo
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Screen_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2121,7 +2226,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Overlay_impl(uint *dest,
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2147,7 +2254,9 @@ static void QT_FASTCALL comp_func_solid_Overlay(uint *dest, int length, uint col
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Overlay_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2190,7 +2299,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Darken_impl(uint *dest, i
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2216,7 +2327,9 @@ static void QT_FASTCALL comp_func_solid_Darken(uint *dest, int length, uint colo
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Darken_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2259,7 +2372,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Lighten_impl(uint *dest,
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2285,7 +2400,9 @@ static void QT_FASTCALL comp_func_solid_Lighten(uint *dest, int length, uint col
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Lighten_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2338,7 +2455,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_ColorDodge_impl(uint *des
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2364,7 +2483,9 @@ static void QT_FASTCALL comp_func_solid_ColorDodge(uint *dest, int length, uint
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_ColorDodge_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2418,7 +2539,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_ColorBurn_impl(uint *dest
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2444,7 +2567,9 @@ static void QT_FASTCALL comp_func_solid_ColorBurn(uint *dest, int length, uint c
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_ColorBurn_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2494,7 +2619,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_HardLight_impl(uint *dest
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2520,7 +2647,9 @@ static void QT_FASTCALL comp_func_solid_HardLight(uint *dest, int length, uint c
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_HardLight_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2579,7 +2708,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_SoftLight_impl(uint *dest
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2605,7 +2736,9 @@ static void QT_FASTCALL comp_func_solid_SoftLight(uint *dest, int length, uint c
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_SoftLight_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2648,7 +2781,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Difference_impl(uint *des
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2674,7 +2809,9 @@ static void QT_FASTCALL comp_func_solid_Difference(uint *dest, int length, uint
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Difference_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2711,7 +2848,9 @@ Q_STATIC_TEMPLATE_FUNCTION inline void QT_FASTCALL comp_func_solid_Exclusion_imp
     int sg = qGreen(color);
     int sb = qBlue(color);
 
+    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2737,7 +2876,9 @@ static void QT_FASTCALL comp_func_solid_Exclusion(uint *dest, int length, uint c
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Exclusion_impl(uint *dest, const uint *src, int length, const T &coverage)
 {
+    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -7416,7 +7557,7 @@ static void qt_alphamapblit_quint32(QRasterBuffer *rasterBuffer,
 #endif
                     {
                         int ialpha = 255 - coverage;
-                        dest[i] = BYTE_MUL(c, uint(coverage)) + BYTE_MUL(dest[i], ialpha);
+                        dest[i] = INTERPOLATE_PIXEL_255(c, coverage, dest[i], ialpha);
                     }
                 }
             }
@@ -7457,7 +7598,7 @@ static void qt_alphamapblit_quint32(QRasterBuffer *rasterBuffer,
 #endif
                         {
                             int ialpha = 255 - coverage;
-                            dest[xp] = BYTE_MUL(c, uint(coverage)) + BYTE_MUL(dest[xp], ialpha);
+                            dest[xp] = INTERPOLATE_PIXEL_255(c, coverage, dest[xp], ialpha);
                         }
                     }
 
@@ -8043,6 +8184,96 @@ static uint detectCPUFeatures()
 #endif
 }
 
+#if defined(Q_CC_RVCT) && defined(QT_HAVE_ARMV6)
+// Move these to qdrawhelper_arm.c when all
+// functions are implemented using arm assembly.
+static CompositionFunctionSolid qt_functionForModeSolid_ARMv6[numCompositionFunctions] = {
+        comp_func_solid_SourceOver,
+        comp_func_solid_DestinationOver,
+        comp_func_solid_Clear,
+        comp_func_solid_Source,
+        comp_func_solid_Destination,
+        comp_func_solid_SourceIn,
+        comp_func_solid_DestinationIn,
+        comp_func_solid_SourceOut,
+        comp_func_solid_DestinationOut,
+        comp_func_solid_SourceAtop,
+        comp_func_solid_DestinationAtop,
+        comp_func_solid_XOR,
+        comp_func_solid_Plus,
+        comp_func_solid_Multiply,
+        comp_func_solid_Screen,
+        comp_func_solid_Overlay,
+        comp_func_solid_Darken,
+        comp_func_solid_Lighten,
+        comp_func_solid_ColorDodge,
+        comp_func_solid_ColorBurn,
+        comp_func_solid_HardLight,
+        comp_func_solid_SoftLight,
+        comp_func_solid_Difference,
+        comp_func_solid_Exclusion,
+        rasterop_solid_SourceOrDestination,
+        rasterop_solid_SourceAndDestination,
+        rasterop_solid_SourceXorDestination,
+        rasterop_solid_NotSourceAndNotDestination,
+        rasterop_solid_NotSourceOrNotDestination,
+        rasterop_solid_NotSourceXorDestination,
+        rasterop_solid_NotSource,
+        rasterop_solid_NotSourceAndDestination,
+        rasterop_solid_SourceAndNotDestination
+};
+
+static CompositionFunction qt_functionForMode_ARMv6[numCompositionFunctions] = {
+        comp_func_SourceOver_armv6,
+        comp_func_DestinationOver,
+        comp_func_Clear,
+        comp_func_Source_armv6,
+        comp_func_Destination,
+        comp_func_SourceIn,
+        comp_func_DestinationIn,
+        comp_func_SourceOut,
+        comp_func_DestinationOut,
+        comp_func_SourceAtop,
+        comp_func_DestinationAtop,
+        comp_func_XOR,
+        comp_func_Plus,
+        comp_func_Multiply,
+        comp_func_Screen,
+        comp_func_Overlay,
+        comp_func_Darken,
+        comp_func_Lighten,
+        comp_func_ColorDodge,
+        comp_func_ColorBurn,
+        comp_func_HardLight,
+        comp_func_SoftLight,
+        comp_func_Difference,
+        comp_func_Exclusion,
+        rasterop_SourceOrDestination,
+        rasterop_SourceAndDestination,
+        rasterop_SourceXorDestination,
+        rasterop_NotSourceAndNotDestination,
+        rasterop_NotSourceOrNotDestination,
+        rasterop_NotSourceXorDestination,
+        rasterop_NotSource,
+        rasterop_NotSourceAndDestination,
+        rasterop_SourceAndNotDestination
+};
+
+static void qt_blend_color_argb_armv6(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    CompositionFunctionSolid func = qt_functionForModeSolid_ARMv6[data->rasterBuffer->compositionMode];
+    while (count--) {
+        uint *target = ((uint *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+        func(target, spans->len, data->solid.color, spans->coverage);
+        ++spans;
+    }
+}
+
+#endif // Q_CC_RVCT && QT_HAVE_ARMV6
+
+
 void qInitDrawhelperAsm()
 {
     static uint features = 0xffffffff;
@@ -8158,6 +8389,20 @@ void qInitDrawhelperAsm()
 
 #endif // QT_NO_DEBUG
 
+#if defined(Q_CC_RVCT) && defined(QT_HAVE_ARMV6)
+        functionForModeAsm = qt_functionForMode_ARMv6;
+        functionForModeSolidAsm = qt_functionForModeSolid_ARMv6;
+
+        qt_memfill32 = qt_memfill32_armv6;
+
+        qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_armv6;
+
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_armv6;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_armv6;
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_armv6;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_armv6;
+#endif // Q_CC_RVCT && QT_HAVE_ARMV6
+
     if (functionForModeSolidAsm) {
         const int destinationMode = QPainter::CompositionMode_Destination;
         functionForModeSolidAsm[destinationMode] = functionForModeSolid_C[destinationMode];
diff --git a/src/gui/painting/qdrawhelper_armv6_p.h b/src/gui/painting/qdrawhelper_armv6_p.h
new file mode 100644
index 0000000..a4c1df2
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_armv6_p.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDRAWHELPER_ARMV6_P_H
+#define QDRAWHELPER_ARMV6_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qdrawhelper_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#if defined(Q_CC_RVCT) && defined(QT_HAVE_ARMV6)
+
+extern "C" void qt_blend_rgb32_on_rgb32_armv6(uchar *destPixels, int dbpl,
+                                            const uchar *srcPixels, int sbpl,
+                                            int w, int h,
+                                            int const_alpha);
+
+extern "C" void qt_blend_argb32_on_argb32_armv6(uchar *destPixels, int dbpl,
+                                            const uchar *srcPixels, int sbpl,
+                                            int w, int h,
+                                            int const_alpha);
+
+extern "C" void qt_memfill32_armv6(quint32 *dest, quint32 value, int count);
+
+extern "C" void comp_func_Source_armv6(uint *dest, const uint *src, int length, uint const_alpha);
+extern "C" void comp_func_SourceOver_armv6(uint *dest, const uint *src, int length, uint const_alpha);
+
+#endif // QT_HAVE_ARMV6
+
+QT_END_NAMESPACE
+
+#endif // QDRAWHELPER_ARMV6_P_H
diff --git a/src/gui/painting/qdrawhelper_armv6_rvct.inc b/src/gui/painting/qdrawhelper_armv6_rvct.inc
new file mode 100644
index 0000000..b3e0605
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_armv6_rvct.inc
@@ -0,0 +1,496 @@
+;/****************************************************************************
+;**
+;** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+;** Contact: Qt Software Information (qt-info@nokia.com)
+;**
+;** This file is part of the QtGui module of the Qt Toolkit.
+;**
+;** $QT_BEGIN_LICENSE:LGPL$
+;** No Commercial Usage
+;** This file contains pre-release code and may not be distributed.
+;** You may use this file in accordance with the terms and conditions
+;** contained in the either Technology Preview License Agreement or the
+;** Beta Release License Agreement.
+;**
+;** GNU Lesser General Public License Usage
+;** Alternatively, this file may be used under the terms of the GNU Lesser
+;** General Public License version 2.1 as published by the Free Software
+;** Foundation and appearing in the file LICENSE.LGPL included in the
+;** packaging of this file.  Please review the following information to
+;** ensure the GNU Lesser General Public License version 2.1 requirements
+;** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+;**
+;** In addition, as a special exception, Nokia gives you certain
+;** additional rights. These rights are described in the Nokia Qt LGPL
+;** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+;** package.
+;**
+;** GNU General Public License Usage
+;** Alternatively, this file may be used under the terms of the GNU
+;** General Public License version 3.0 as published by the Free Software
+;** Foundation and appearing in the file LICENSE.GPL included in the
+;** packaging of this file.  Please review the following information to
+;** ensure the GNU General Public License version 3.0 requirements will be
+;** met: http://www.gnu.org/copyleft/gpl.html.
+;**
+;** If you are unsure which license is appropriate for your use, please
+;** contact the sales department at qt-sales@nokia.com.
+;** $QT_END_LICENSE$
+;**
+;****************************************************************************/
+
+;
+;  W A R N I N G
+;  -------------
+;
+; This file is not part of the Qt API.  It exists purely as an
+; implementation detail.  This header file may change from version to
+; version without notice, or even be removed.
+;
+; We mean it.
+;
+
+;-----------------------------------------------------------------------------
+; Globals.
+; Earch marcro expects that caller has loaded 0x800080 to r14. 
+;-----------------------------------------------------------------------------
+
+ComponentHalf	EQU	0x800080		
+
+;-----------------------------------------------------------------------------
+; ARM assembly implementations of accelerated graphics operations.
+;
+; Conventions:
+;
+; 	- r0 = Target buffer pointer
+;	- r1 = Source buffer pointer
+; 	- r2 = Length of the buffer to blend
+;	- r3 = Constant alpha for source buffer 
+;
+;-----------------------------------------------------------------------------
+
+; A macro for transparently defining ARM functions
+		MACRO
+$func	Function
+		AREA Function_$func, CODE
+		GLOBAL $func
+		ALIGN 4
+		CODE32
+$func
+		MEND
+		
+		
+;-----------------------------------------------------------------------------
+; Armv6 boosted implementation of BYTE_MUL(...) function found in qdrawhelper_p.h.
+;
+;  @param dst	Destination register where to store the result
+;  @param x     Value to multiply
+;  @param a     Multiplicator byte
+;  @param r14   Component half 0x800080
+;
+;  @note Trashes x, r8
+;-----------------------------------------------------------------------------
+		MACRO
+		ByteMul $dst, $x, $a
+
+		; static inline uint BYTE_MUL(uint x, uint a)
+
+		; uint r8 = (x & 0xff00ff) * a + 0x800080
+		uxtb16	r8, $x	; r8 = r8 & 0x00FF00FF
+		mla		r8, r8, $a, r14
+		
+		; x = ((r >> 8) & 0xff00ff) * a + 0x800080
+		uxtb16	$x, $x, ror #8
+		mla		$x, $x, $a, r14
+
+				
+		; r8 = (r8 + ((r8 >> 8) & 0xff00ff) ) >> 8
+		; r8 &= 0xff00ff
+		uxtab16	r8, r8, r8, ror #8
+		uxtb16	r8, r8, ror #8
+			
+		; x = x + ((x >>8) & 0xff00ff)
+		uxtab16	$x, $x, $x, ror #8
+		
+		; x &= 0xff00ff00
+		; x |= r8
+		uxtb16	$x, $x, ror #8
+		orr		$dst, r8, $x, lsl #8
+		
+		MEND
+		
+;-----------------------------------------------------------------------------
+; Armv6 boosted implementation of INTERPOLATE_PIXEL_255(...) function found in 
+; qdrawhelper_p.h.
+;
+;  @param dst	Destination register where to store the result
+;  @param x     First value to multiply
+;  @param a		Multiplicator byte for first value
+;  @param y     Second value to multiply
+;  @param b     Multiplicator byte for second value
+;  @param r14   Component half 0x800080
+;  
+;
+;  @note Trashes x, r8, r14
+;-----------------------------------------------------------------------------
+		MACRO
+		InterpolatePixel255 $dst, $x, $a, $y, $b
+
+		; static inline uint INTERPOLATE_PIXEL_255(uint x, uint a, uint y, uint b)
+
+		; First calculate the parts where we need 0x800080
+
+		; uint r8 = (((x & 0xff00ff) * a) + 0x800080)
+		uxtb16	r8, $x	; r8 = r8 & 0x00FF00FF
+		mla		r8, r8, $a, r14
+		
+		; x = ((((x >> 8) & 0xff00ff) * a) + 0x800080)
+		uxtb16	$x, $x, ror #8
+		mla		$x, $x, $a, r14
+		
+		; Now we are trashing r14 to free it for other purposes
+		
+		; uint r14 = (y & 0xff00ff) * b
+		uxtb16	r14, $y	; r14 = y & 0x00FF00FF
+		mul		r14, r14, $b
+		
+		; r8 = r8 + r14
+		add		r8, r8, r14
+		
+		; r8 = (r8 + ((r8 >> 8) & 0xff00ff) ) >> 8
+		; r8 &= 0xff00ff
+		uxtab16	r8, r8, r8, ror #8
+		uxtb16	r8, r8, ror #8
+		
+		; r14 = ((y >> 8) & 0xff00ff) * b
+		uxtb16	r14, $y, ror #8	; r14 = ((y >> 8) & 0xFF00FF)
+		mul		r14, r14, $b
+		
+		; x = x + r14
+		add		$x, $x, r14
+			
+		; x = x + ((x >>8) & 0xff00ff)
+		uxtab16	$x, $x, $x, ror #8
+		
+		; x &= 0xff00ff00
+		; x |= r8
+		uxtb16	$x, $x, ror #8
+		orr		$dst, r8, $x, lsl #8
+		
+		MEND
+
+;-----------------------------------------------------------------------------
+;
+;-----------------------------------------------------------------------------
+		MACRO
+$label	Blend4Pixels $BlendPixel
+		
+		; Blend first 4 pixels		
+		
+		ldmia	r1!, {r4-r7}
+		ldm		r0, {r9-r12}
+		
+b4p1_$label	$BlendPixel r9, r4, r3
+b4p2_$label	$BlendPixel r10, r5, r3
+b4p3_$label	$BlendPixel r11, r6, r3
+b4p4_$label	$BlendPixel r12, r7, r3
+		
+		stmia 	r0!, {r9-r12}
+		
+		MEND
+
+;-----------------------------------------------------------------------------
+;
+;-----------------------------------------------------------------------------
+		MACRO
+$label	Blend8Pixels $BlendPixel
+		
+b8p1_$label Blend4Pixels $BlendPixel
+b8p2_$label Blend4Pixels $BlendPixel		
+				
+		MEND
+		
+;-----------------------------------------------------------------------------
+;
+;-----------------------------------------------------------------------------
+		MACRO
+$label	Blend16Pixels $BlendPixel
+		
+b16p1_$label Blend8Pixels $BlendPixel
+b16p2_$label Blend8Pixels $BlendPixel		
+				
+		MEND
+		
+;-----------------------------------------------------------------------------
+;
+;-----------------------------------------------------------------------------
+		MACRO
+$label	Blend32Pixels $BlendPixel
+		
+b32p1_$label Blend16Pixels $BlendPixel
+b32p2_$label Blend16Pixels $BlendPixel		
+				
+		MEND
+
+;-----------------------------------------------------------------------------
+; A macro for source over compositing one row of pixels and saving the results 
+; to destination buffer.
+;
+; @param dest			Destination	buffer						(r0)
+; @param src			Source buffer							(r1)
+; @param length			Length									(r2)
+; @param const_alpha	Constant alpha					  		(r3)
+; @param r14 			Component Half (0x800080)		  		(r14)	
+;
+;  @note Advances r0, r1
+;  @note Trashes r2, r4-r12
+;-----------------------------------------------------------------------------
+		MACRO
+$label	BlendRow $BlendPixel
+
+		pld		[r1]
+
+bloop_$label
+		; Blend 32 pixels per loop iteration
+		subs	r2, r2, #32
+		bmi		b_remaining_$label
+
+brp1_$label	Blend32Pixels $BlendPixel
+
+		b		bloop_$label
+
+b_remaining_$label
+		
+		; Remaining 31 pixels
+		
+		addmi	r2, r2, #32
+
+		; Blend 16 pixels
+		tst		r2, #16
+		beq		b_remaining8_$label
+		
+brp2_$label Blend16Pixels $BlendPixel
+	
+b_remaining8_$label	
+		
+		; Blend 8 pixels
+		tst		r2, #8
+		beq		b_remaining4_$label
+		
+brp3_$label Blend8Pixels $BlendPixel			
+		
+b_remaining4_$label		
+		
+		; Blend 4 pixels
+		tst		r2, #4
+		beq		b_remaining3_$label
+		
+brp4_$label Blend4Pixels $BlendPixel			
+
+b_remaining3_$label
+
+		; Remaining 3 pixels
+	
+		tst		r2, #2
+		beq		b_last_$label
+		
+		ldmia 	r1!, {r4-r5}
+		ldm	  	r0,  {r9-r10}
+		
+brp5_$label	$BlendPixel r9, r4, r3
+brp6_$label	$BlendPixel r10, r5, r3
+		
+		stmia 	r0!, {r9-r10}
+
+b_last_$label
+		
+		tst		r2, #1
+		beq		bexit_$label
+		
+		ldr		r4, [r1]
+		ldr		r9, [r0]
+
+bpl_$label	$BlendPixel r9, r4, r3
+		
+		str 	r9, [r0]
+
+bexit_$label
+
+		MEND
+		
+;-----------------------------------------------------------------------------
+; A macro for source over compositing one row of pixels and saving the results 
+; to destination buffer. Restores all registers.
+;
+; @param dest			Destination	buffer						(r0)
+; @param src			Source buffer							(r1)
+; @param length			Length									(r2)
+; @param const_alpha	Constant alpha					  		(r3)
+; @param r14 			Component Half (0x800080)		  		(r14)	
+;
+;  @note Advances r0, r1
+;  @note Trashes r2, r4-r12
+;-----------------------------------------------------------------------------
+		MACRO
+$label	BlendRowSafe $BlendPixel
+
+		stmfd	sp!, {r0-r6} ; Preserves registers only up to r6
+
+brs_$label  BlendRow $BlendPixel		
+
+		ldmfd	sp!, {r0-r6}
+
+		MEND		
+		
+
+;-----------------------------------------------------------------------------
+; Pix Copy. 
+; NOTE! Cache line size of ARM1136JF-S and ARM1136J-S is 32 bytes (8 pixels). 
+;
+; @param dst			Destination	pixels						(r0)
+; @param src			Source pixels							(r1)
+; @param len			Length									(r2)
+;
+;  @note Trashes r3-r10
+;-----------------------------------------------------------------------------
+		MACRO
+$label	PixCpy $dst, $src, $len
+
+		pld		[$src]
+
+pcpy_loop_$label
+		; Copy 8 pixels per loop iteration
+		pld		[$src, #96]
+		subs	$len, $len, #8
+		ldmgeia	$src!, {r3-r10}
+		stmgeia	$dst!, {r3-r10}
+		bgt		pcpy_loop_$label
+
+pcpy_remaining_$label
+
+		; Copy up to 7 remaining pixels
+		
+		; Copy 4 pixels
+		tst		$len, #4
+		ldmneia	$src!, {r3-r6}
+		stmneia	$dst!, {r3-r6}
+
+		tst		$len, #2
+		ldmneia	$src!, {r3-r4}
+		stmneia	$dst!, {r3-r4}
+
+		tst		$len, #1
+		ldrne	r3, [$src]
+		strne 	r3, [$dst]
+
+		MEND
+		
+;-----------------------------------------------------------------------------
+; General Pix Copy. Maximum 8 pixels at time. Restores all registers. 
+;
+; @param dst			Destination	pixels						(r0)
+; @param src			Source pixels							(r1)
+; @param len			Length									(r2)
+;
+;  @note Trashes r3-r10
+;-----------------------------------------------------------------------------
+		MACRO
+$label	PixCpySafe $dst, $src, $len
+
+		stmfd	sp!, {r0-r6} ; Preserves registers only up to r6
+
+pcs_$label  PixCpy $dst, $src, $len
+
+		ldmfd	sp!, {r0-r6}		; pop
+		
+		MEND
+		
+		
+;-----------------------------------------------------------------------------
+; A macro for source over compositing one pixel and saving the result to
+; dst register.
+;
+;  @param dst      Destination register, must contain destination pixel upon entry
+;  @param src 	   Source register, must contain source pixel upon entry
+;  @param const_alpha Constant source alpha
+;  @param r14	   Component half 0x800080
+;
+;  @note Trashes const_alpha, r8
+;-----------------------------------------------------------------------------
+		MACRO
+$label	PixelSourceOver $dst, $src, $const_alpha
+
+		; Negate src and extract alpha
+		mvn		$const_alpha, $src ; bitwise not
+		uxtb	$const_alpha, $const_alpha, ror #24	; r3 = ((r3 & 0xFF000000) >> 24);  
+
+		;cmp		$const_alpha, #255	; test for full transparency ( negated )
+		;beq		exit_$label
+		cmp     $const_alpha, #0	            ; test for full opacity ( negated )
+		moveq	$dst, $src
+		beq		exit_$label
+
+		ByteMul	$dst, $dst, $const_alpha	
+		add		$dst, $src, $dst
+		
+exit_$label
+		MEND
+		
+;-----------------------------------------------------------------------------
+; A macro for source over compositing one pixel and saving the result to
+; dst register.
+;
+;  @param dst      Destination register, must contain destination pixel upon entry
+;  @param src 	   Source register, must contain source pixel upon entry
+;  @param const_alpha Constant source alpha
+;  @param r14	   Component half 0x800080
+;
+;  @note Trashes src, const_alpha, r8
+;-----------------------------------------------------------------------------
+		MACRO
+$label	PixelSourceOverConstAlpha $dst, $src, $const_alpha
+
+		; store alpha because we are going to trash it
+		stmfd	sp!, {$const_alpha}
+
+		ByteMul	$src, $src, $const_alpha
+
+		; Negate src and extract alpha
+		mvn		$const_alpha, $src ; bitwise not
+		uxtb	$const_alpha, $const_alpha, ror #24	; r3 = ((r3 & 0xFF000000) >> 24);  
+
+		ByteMul	$dst, $dst, $const_alpha
+
+		add		$dst, $src, $dst
+
+		; recover alpha
+		ldmfd	sp!, {$const_alpha}
+
+		MEND		
+		
+;-----------------------------------------------------------------------------
+; A macro for source over compositing one pixel and saving the result to
+; a register.
+;
+;  @param dst      Destination register, must contain destination pixel upon entry
+;  @param src 	   Source register, must contain source pixel upon entry
+;  @param const_alpha Constant source alpha
+;  @param r14	   Component half 0x800080
+;
+;  @note Trashes src, r8
+;-----------------------------------------------------------------------------
+		MACRO
+$label	PixelSourceConstAlpha $dst, $src, $const_alpha
+
+		; store r2 and r14 because we are going to trash them
+		stmfd	sp!, {r2, r14}
+
+		rsb		r2, $const_alpha, #255
+		InterpolatePixel255 $dst, $src, $const_alpha, $dst, r2
+
+		; recover r2 and r14
+		ldmfd	sp!, {r2, r14}
+
+		MEND		
+		
+		END ; File end
diff --git a/src/gui/painting/qdrawhelper_armv6_rvct.s b/src/gui/painting/qdrawhelper_armv6_rvct.s
new file mode 100644
index 0000000..3ffe48b
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_armv6_rvct.s
@@ -0,0 +1,178 @@
+;/****************************************************************************
+;**
+;** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+;** Contact: Qt Software Information (qt-info@nokia.com)
+;**
+;** This file is part of the QtGui module of the Qt Toolkit.
+;**
+;** $QT_BEGIN_LICENSE:LGPL$
+;** No Commercial Usage
+;** This file contains pre-release code and may not be distributed.
+;** You may use this file in accordance with the terms and conditions
+;** contained in the either Technology Preview License Agreement or the
+;** Beta Release License Agreement.
+;**
+;** GNU Lesser General Public License Usage
+;** Alternatively, this file may be used under the terms of the GNU Lesser
+;** General Public License version 2.1 as published by the Free Software
+;** Foundation and appearing in the file LICENSE.LGPL included in the
+;** packaging of this file.  Please review the following information to
+;** ensure the GNU Lesser General Public License version 2.1 requirements
+;** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+;**
+;** In addition, as a special exception, Nokia gives you certain
+;** additional rights. These rights are described in the Nokia Qt LGPL
+;** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+;** package.
+;**
+;** GNU General Public License Usage
+;** Alternatively, this file may be used under the terms of the GNU
+;** General Public License version 3.0 as published by the Free Software
+;** Foundation and appearing in the file LICENSE.GPL included in the
+;** packaging of this file.  Please review the following information to
+;** ensure the GNU General Public License version 3.0 requirements will be
+;** met: http://www.gnu.org/copyleft/gpl.html.
+;**
+;** If you are unsure which license is appropriate for your use, please
+;** contact the sales department at qt-sales@nokia.com.
+;** $QT_END_LICENSE$
+;**
+;****************************************************************************/
+
+;
+;  W A R N I N G
+;  -------------
+;
+; This file is not part of the Qt API.  It exists purely as an
+; implementation detail.  This header file may change from version to
+; version without notice, or even be removed.
+;
+; We mean it.
+;
+
+		ARM
+		PRESERVE8
+		
+		INCLUDE		qdrawhelper_armv6_rvct.inc
+		
+;-----------------------------------------------------------------------------
+; qt_memfill32_armv6
+; 
+; @brief Not yet in use!
+;
+; @param dest			Destination	buffer						(r0)
+; @param value			Value									(r1)
+; @param count			Count									(r2)
+; 
+;---------------------------------------------------------------------------
+qt_memfill32_armv6 Function
+		stmfd	sp!, {r4-r12, r14}
+		
+		mov		r3, r1
+		mov		r4, r1
+		mov		r5, r1
+		mov		r6, r1
+		mov		r7, r1
+		mov		r8, r1
+		mov		r9, r1
+	
+mfill_loop
+		; Fill 32 pixels per loop iteration
+		subs	r2, r2, #32
+		stmgeia	r0!, {r1, r3, r4, r5, r6, r7, r8, r9}
+		stmgeia	r0!, {r1, r3, r4, r5, r6, r7, r8, r9}
+		stmgeia	r0!, {r1, r3, r4, r5, r6, r7, r8, r9}
+		stmgeia	r0!, {r1, r3, r4, r5, r6, r7, r8, r9}
+		bgt		mfill_loop
+
+mfill_remaining
+
+		; Fill up to 31 remaining pixels
+		
+		; Fill 16 pixels
+		tst		r2, #16
+		stmneia	r0!, {r1, r3, r4, r5, r6, r7, r8, r9}
+		stmneia	r0!, {r1, r3, r4, r5, r6, r7, r8, r9}
+		
+		; Fill 8 pixels
+		tst		r2, #8
+		stmneia	r0!, {r1, r3, r4, r5, r6, r7, r8, r9}
+		
+		; Fill 4 pixels
+		tst		r2, #4
+		stmneia	r0!, {r1, r3, r4, r5}
+
+		; Fill 2 pixels
+		tst		r2, #2
+		stmneia	r0!, {r1, r3}
+
+		; Fill last one
+		tst		r2, #1
+		strne 	r1, [r0]
+		
+		ldmfd	sp!, {r4-r12, pc}		; pop and return
+					
+;-----------------------------------------------------------------------------
+; comp_func_Source_arm
+; 
+; @brief 
+;
+; @param dest			Destination	buffer						(r0)
+; @param src			Source buffer							(r1)
+; @param length			Length									(r2)
+; @param const_alpha	Constant alpha							(r3)
+; 
+;---------------------------------------------------------------------------
+comp_func_Source_armv6 Function
+		stmfd	sp!, {r4-r12, r14}
+	
+		cmp		r3, #255 ; if(r3 == 255)
+		bne		src2 ; branch if not
+	
+src1	PixCpy	r0, r1, r2
+
+		ldmfd	sp!, {r4-r12, pc}		; pop and return
+
+src2	
+		;ldr		r14, =ComponentHalf ; load 0x800080 to r14
+		mov		r14, #0x800000
+		add		r14, r14, #0x80
+
+src22   BlendRow PixelSourceConstAlpha
+
+		ldmfd	sp!, {r4-r12, pc}		; pop and return
+
+;-----------------------------------------------------------------------------
+; comp_func_SourceOver_arm
+; 
+; @brief 
+;
+; @param dest			Destination	buffer						(r0)
+; @param src			Source buffer							(r1)
+; @param length			Length									(r2)
+; @param const_alpha	Constant alpha							(r3)
+; 
+;---------------------------------------------------------------------------
+comp_func_SourceOver_armv6 Function
+		stmfd	sp!, {r4-r12, r14}
+	
+		;ldr		r14, =ComponentHalf ; load 0x800080 to r14
+		mov		r14, #0x800000
+		add		r14, r14, #0x80
+	
+		cmp		r3, #255 ; if(r3 == 255)
+		bne		srcovr2 ; branch if not
+	
+srcovr1	 BlendRow PixelSourceOver
+		
+		ldmfd	sp!, {r4-r12, pc}		; pop and return
+
+srcovr2
+ 
+srcovr22  BlendRow PixelSourceOverConstAlpha
+
+		ldmfd	sp!, {r4-r12, pc}		; pop and return
+		
+
+		END	; File end		
+