diff options
| -rw-r--r-- | gyp/opts.gypi | 1 | ||||
| -rw-r--r-- | src/opts/SkBlitRow_opts_SSE4.cpp | 66 | ||||
| -rw-r--r-- | src/opts/SkBlitRow_opts_SSE4.h | 23 | ||||
| -rw-r--r-- | src/opts/SkBlitRow_opts_SSE4_asm.S | 475 | ||||
| -rw-r--r-- | src/opts/SkBlitRow_opts_SSE4_x64_asm.S | 472 | ||||
| -rw-r--r-- | src/opts/SkColor_opts_SSE2.h | 9 | ||||
| -rw-r--r-- | src/opts/opts_check_x86.cpp | 6 |
7 files changed, 80 insertions, 972 deletions
diff --git a/gyp/opts.gypi b/gyp/opts.gypi index f6257a97b4..dfcf434aff 100644 --- a/gyp/opts.gypi +++ b/gyp/opts.gypi @@ -79,5 +79,6 @@ ], 'sse41_sources': [ '<(skia_src_path)/opts/SkBlurImage_opts_SSE4.cpp', + '<(skia_src_path)/opts/SkBlitRow_opts_SSE4.cpp', ], } diff --git a/src/opts/SkBlitRow_opts_SSE4.cpp b/src/opts/SkBlitRow_opts_SSE4.cpp new file mode 100644 index 0000000000..fd837d54fe --- /dev/null +++ b/src/opts/SkBlitRow_opts_SSE4.cpp @@ -0,0 +1,66 @@ +#include "SkBlitRow_opts_SSE4.h" + +// Some compilers can't compile SSSE3 or SSE4 intrinsics. We give them stub methods. +// The stubs should never be called, so we make them crash just to confirm that. +#if SK_CPU_SSE_LEVEL < SK_CPU_SSE_LEVEL_SSE41 +void S32A_Opaque_BlitRow32_SSE4(SkPMColor* SK_RESTRICT, const SkPMColor* SK_RESTRICT, int, U8CPU) { + sk_throw(); +} + +#else + +#include <emmintrin.h> // SSE2: Most _mm_foo() in this file. +#include <smmintrin.h> // SSE4.1: _mm_testz_si128 and _mm_testc_si128. + +#include "SkColorPriv.h" +#include "SkColor_opts_SSE2.h" + +void S32A_Opaque_BlitRow32_SSE4(SkPMColor* SK_RESTRICT dst, + const SkPMColor* SK_RESTRICT src, + int count, + U8CPU alpha) { + SkASSERT(alpha == 255); + // As long as we can, we'll work on 16 pixel pairs at once. + int count16 = count / 16; + __m128i* dst4 = (__m128i*)dst; + const __m128i* src4 = (const __m128i*)src; + + for (int i = 0; i < count16 * 4; i += 4) { + // Load 16 source pixels. + __m128i s0 = _mm_loadu_si128(src4+i+0), + s1 = _mm_loadu_si128(src4+i+1), + s2 = _mm_loadu_si128(src4+i+2), + s3 = _mm_loadu_si128(src4+i+3); + + const __m128i alphaMask = _mm_set1_epi32(0xFF << SK_A32_SHIFT); + const __m128i ORed = _mm_or_si128(s3, _mm_or_si128(s2, _mm_or_si128(s1, s0))); + if (_mm_testz_si128(ORed, alphaMask)) { + // All 16 source pixels are fully transparent. There's nothing to do! + continue; + } + const __m128i ANDed = _mm_and_si128(s3, _mm_and_si128(s2, _mm_and_si128(s1, s0))); + if (_mm_testc_si128(ANDed, alphaMask)) { + // All 16 source pixels are fully opaque. There's no need to read dst or blend it. + _mm_storeu_si128(dst4+i+0, s0); + _mm_storeu_si128(dst4+i+1, s1); + _mm_storeu_si128(dst4+i+2, s2); + _mm_storeu_si128(dst4+i+3, s3); + continue; + } + // The general slow case: do the blend for all 16 pixels. + _mm_storeu_si128(dst4+i+0, SkPMSrcOver_SSE2(s0, _mm_loadu_si128(dst4+i+0))); + _mm_storeu_si128(dst4+i+1, SkPMSrcOver_SSE2(s1, _mm_loadu_si128(dst4+i+1))); + _mm_storeu_si128(dst4+i+2, SkPMSrcOver_SSE2(s2, _mm_loadu_si128(dst4+i+2))); + _mm_storeu_si128(dst4+i+3, SkPMSrcOver_SSE2(s3, _mm_loadu_si128(dst4+i+3))); + } + + // Wrap up the last <= 15 pixels. + for (int i = count16*16; i < count; i++) { + // This check is not really necessarily, but it prevents pointless autovectorization. + if (src[i] & 0xFF000000) { + dst[i] = SkPMSrcOver(src[i], dst[i]); + } + } +} + +#endif diff --git a/src/opts/SkBlitRow_opts_SSE4.h b/src/opts/SkBlitRow_opts_SSE4.h index 600e669893..577ace6f8f 100644 --- a/src/opts/SkBlitRow_opts_SSE4.h +++ b/src/opts/SkBlitRow_opts_SSE4.h @@ -10,24 +10,9 @@ #include "SkBlitRow.h" -#ifdef CRBUG_399842_FIXED - -/* Check if we are able to build assembly code, GCC/AT&T syntax: - * 1) Clang and GCC are generally OK. OS X's old LLVM-GCC 4.2 can't handle it; - * 2) We're intentionally not linking this in even when supported (Clang) on Windows; - * 3) MemorySanitizer cannot instrument assembly at all. - */ -#if /* 1)*/ (defined(__clang__) || (defined(__GNUC__) && !defined(SK_BUILD_FOR_MAC))) \ - /* 2)*/ && !defined(SK_BUILD_FOR_WIN) \ - /* 3)*/ && !defined(MEMORY_SANITIZER) -extern "C" void S32A_Opaque_BlitRow32_SSE4_asm(SkPMColor* SK_RESTRICT dst, - const SkPMColor* SK_RESTRICT src, - int count, U8CPU alpha); - -#define SK_ATT_ASM_SUPPORTED -#endif - -#endif // CRBUG_399842_FIXED - +void S32A_Opaque_BlitRow32_SSE4(SkPMColor* SK_RESTRICT, + const SkPMColor* SK_RESTRICT, + int count, + U8CPU alpha); #endif diff --git a/src/opts/SkBlitRow_opts_SSE4_asm.S b/src/opts/SkBlitRow_opts_SSE4_asm.S deleted file mode 100644 index 0f5281713d..0000000000 --- a/src/opts/SkBlitRow_opts_SSE4_asm.S +++ /dev/null @@ -1,475 +0,0 @@ -/* - * Copyright 2014 The Android Open Source Project - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#ifdef CRBUG_399842_FIXED - -#if defined(__clang__) || (defined(__GNUC__) && !defined(SK_BUILD_FOR_MAC)) - -#define CFI_PUSH(REG) \ - .cfi_adjust_cfa_offset 4; \ - .cfi_rel_offset REG, 0 - -#define CFI_POP(REG) \ - .cfi_adjust_cfa_offset -4; \ - .cfi_restore REG - -#define PUSH(REG) pushl REG; CFI_PUSH (REG) -#define POP(REG) popl REG; CFI_POP (REG) -#define RETURN POP(%edi); ret - -#define EXTRACT_ALPHA(var1, var2) \ - movdqa %var1, %var2; /* Clone source pixels to extract alpha */\ - psrlw $8, %var2; /* Discard red and blue, leaving alpha and green */\ - pshufhw $0xF5, %var2, %var2; /* Repeat alpha for scaling (high) */\ - movdqa %xmm6, %xmm4; \ - pshuflw $0xF5, %var2, %var2; /* Repeat alpha for scaling (low) */\ - movdqa %xmm5, %xmm3; \ - psubw %var2, %xmm4 /* Finalize alpha calculations */ - -#define SCALE_PIXELS \ - psllw $8, %xmm5; /* Filter out red and blue components */\ - pmulhuw %xmm4, %xmm5; /* Scale red and blue */\ - psrlw $8, %xmm3; /* Filter out alpha and green components */\ - pmullw %xmm4, %xmm3 /* Scale alpha and green */ - - -/* - * void S32A_Opaque_BlitRow32_SSE4(SkPMColor* SK_RESTRICT dst, - * const SkPMColor* SK_RESTRICT src, - * int count, U8CPU alpha) - * - * This function is divided into six blocks: initialization, blit 4-15 pixels, - * blit 0-3 pixels, align destination for 16+ pixel blits, - * blit 16+ pixels with source unaligned, blit 16+ pixels with source aligned. - * There are some code reuse between the blocks. - * - * The primary optimization comes from checking the source pixels' alpha value. - * If the alpha is zero, the pixel can be skipped entirely. - * If the alpha is fully opaque, the pixel can be copied directly to the destination. - * According to collected statistics, these two cases are the most common. - * The main loop(s) uses pre-loading and unrolling in an attempt to reduce the - * memory latency worse-case. - */ - -#ifdef __clang__ - .text -#else - .section .text.sse4.2,"ax",@progbits - .type S32A_Opaque_BlitRow32_SSE4_asm, @function -#endif - .p2align 4 -#if defined(SK_BUILD_FOR_MAC) - .global _S32A_Opaque_BlitRow32_SSE4_asm - .private_extern _S32A_Opaque_BlitRow32_SSE4_asm -_S32A_Opaque_BlitRow32_SSE4_asm: -#else - .global S32A_Opaque_BlitRow32_SSE4_asm - .hidden S32A_Opaque_BlitRow32_SSE4_asm -S32A_Opaque_BlitRow32_SSE4_asm: -#endif - .cfi_startproc - movl 8(%esp), %eax // Source pointer - movl 12(%esp), %ecx // Pixel count - movl 4(%esp), %edx // Destination pointer - prefetcht0 (%eax) - - // Setup SSE constants - pcmpeqd %xmm7, %xmm7 // 0xFF000000 mask to check alpha - pslld $24, %xmm7 - pcmpeqw %xmm6, %xmm6 // 16-bit 256 to calculate inv. alpha - psrlw $15, %xmm6 - psllw $8, %xmm6 - pcmpeqw %xmm0, %xmm0 // 0x00FF00FF mask (Must be in xmm0 because of pblendvb) - psrlw $8, %xmm0 - subl $4, %ecx // Check if we have only 0-3 pixels - js .LReallySmall - PUSH(%edi) - cmpl $11, %ecx // Do we have enough pixels to run the main loop? - ja .LBigBlit - - // Handle small blits (4-15 pixels) - //////////////////////////////////////////////////////////////////////////////// - xorl %edi, %edi // Reset offset to zero - -.LSmallLoop: - lddqu (%eax, %edi), %xmm1 // Load four source pixels - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LSmallAlphaNotOpaqueOrZero - jz .LSmallAlphaZero // If all alphas are zero, skip the pixels completely - movdqu %xmm1, (%edx, %edi) // Store four destination pixels -.LSmallAlphaZero: - addl $16, %edi - subl $4, %ecx // Check if there are four additional pixels, at least - jns .LSmallLoop - jmp .LSmallRemaining - - // Handle mixed alphas (calculate and scale) - .p2align 4 -.LSmallAlphaNotOpaqueOrZero: - lddqu (%edx, %edi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - addl $16, %edi - subl $4, %ecx // Check if there are four additional pixels, at least - pblendvb %xmm5, %xmm3 // Mask in %xmm0, implicitly - paddb %xmm3, %xmm1 // Add source and destination pixels together - movdqu %xmm1, -16(%edx, %edi) // Store four destination pixels - jns .LSmallLoop - - // Handle the last 0-3 pixels (also used by the main loops) -.LSmallRemaining: - cmpl $-4, %ecx // Check if we are done - je .LSmallExit - sall $2, %ecx // Calculate offset for last pixels - addl %ecx, %edi - - lddqu (%eax, %edi), %xmm1 // Load last four source pixels (overlapping) - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - jc .LSmallRemainingStoreAll// If all alphas are opaque, just store (overlapping) - jz .LSmallExit // If all alphas are zero, skip the pixels completely - - // Handle mixed alphas (calculate and scale) - lddqu (%edx, %edi), %xmm5 // Load last four destination pixels (overlapping) - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - - psllw $8, %xmm3 // Filter out red and blue components - pmulhuw %xmm4, %xmm3 // Scale red and blue - movdqa %xmm5, %xmm2 - psrlw $8, %xmm2 // Filter out alpha and green components - pmullw %xmm4, %xmm2 // Scale alpha and green - - cmpl $-8, %ecx // Check how many pixels should be written - pblendvb %xmm3, %xmm2 // Combine results (mask in %xmm0, implicitly) - paddb %xmm2, %xmm1 // Add source and destination pixels together - jb .LSmallPixelsLeft1 - ja .LSmallPixelsLeft3 // To avoid double-blending the overlapping pixels... - pblendw $0xF0, %xmm1, %xmm5 // Merge only the final two pixels to the destination - movdqu %xmm5, (%edx, %edi) // Store last two destination pixels -.LSmallExit: - RETURN - -.LSmallPixelsLeft1: - pblendw $0xC0, %xmm1, %xmm5 // Merge only the final pixel to the destination - movdqu %xmm5, (%edx, %edi) // Store last destination pixel - RETURN - -.LSmallPixelsLeft3: - pblendw $0xFC, %xmm1, %xmm5 // Merge only the final three pixels to the destination - movdqu %xmm5, (%edx, %edi) // Store last three destination pixels - RETURN - -.LSmallRemainingStoreAll: - movdqu %xmm1, (%edx, %edi) // Store last destination pixels (overwrite) - RETURN - - // Handle really small blits (0-3 pixels) - //////////////////////////////////////////////////////////////////////////////// -.LReallySmall: - addl $4, %ecx - jle .LReallySmallExit - pcmpeqd %xmm1, %xmm1 - cmp $2, %ecx // Check how many pixels should be read - pinsrd $0x0, (%eax), %xmm1 // Load one source pixel - pinsrd $0x0, (%edx), %xmm5 // Load one destination pixel - jb .LReallySmallCalc - pinsrd $0x1, 4(%eax), %xmm1 // Load second source pixel - pinsrd $0x1, 4(%edx), %xmm5 // Load second destination pixel - je .LReallySmallCalc - pinsrd $0x2, 8(%eax), %xmm1 // Load third source pixel - pinsrd $0x2, 8(%edx), %xmm5 // Load third destination pixel - -.LReallySmallCalc: - ptest %xmm7, %xmm1 // Check if all alphas are opaque - jc .LReallySmallStore // If all alphas are opaque, just store - - // Handle mixed alphas (calculate and scale) - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - - pand %xmm0, %xmm5 // Filter out red and blue components - pmullw %xmm4, %xmm5 // Scale red and blue - psrlw $8, %xmm3 // Filter out alpha and green components - pmullw %xmm4, %xmm3 // Scale alpha and green - - psrlw $8, %xmm5 // Combine results - pblendvb %xmm5, %xmm3 // Mask in %xmm0, implicitly - paddb %xmm3, %xmm1 // Add source and destination pixels together - -.LReallySmallStore: - cmp $2, %ecx // Check how many pixels should be written - pextrd $0x0, %xmm1, (%edx) // Store one destination pixel - jb .LReallySmallExit - pextrd $0x1, %xmm1, 4(%edx) // Store second destination pixel - je .LReallySmallExit - pextrd $0x2, %xmm1, 8(%edx) // Store third destination pixel -.LReallySmallExit: - ret - - // Handle bigger blit operations (16+ pixels) - //////////////////////////////////////////////////////////////////////////////// - .p2align 4 -.LBigBlit: - // Align destination? - testl $0xF, %edx - lddqu (%eax), %xmm1 // Pre-load four source pixels - jz .LAligned - - movl %edx, %edi // Calculate alignment of destination pointer - negl %edi - andl $0xF, %edi - - // Handle 1-3 pixels to align destination - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - jz .LAlignDone // If all alphas are zero, just skip - lddqu (%edx), %xmm5 // Load four destination pixels - jc .LAlignStore // If all alphas are opaque, just store - - // Handle mixed alphas (calculate and scale) - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - - psllw $8, %xmm3 // Filter out red and blue components - pmulhuw %xmm4, %xmm3 // Scale red and blue - movdqa %xmm5, %xmm2 - psrlw $8, %xmm2 // Filter out alpha and green components - pmullw %xmm4, %xmm2 // Scale alpha and green - - pblendvb %xmm3, %xmm2 // Combine results (mask in %xmm0, implicitly) - paddb %xmm2, %xmm1 // Add source and destination pixels together - -.LAlignStore: - cmp $8, %edi // Check how many pixels should be written - jb .LAlignPixelsLeft1 - ja .LAlignPixelsLeft3 - pblendw $0x0F, %xmm1, %xmm5 // Blend two pixels - jmp .LAlignStorePixels - -.LAlignPixelsLeft1: - pblendw $0x03, %xmm1, %xmm5 // Blend one pixel - jmp .LAlignStorePixels - -.LAlignPixelsLeft3: - pblendw $0x3F, %xmm1, %xmm5 // Blend three pixels - -.LAlignStorePixels: - movdqu %xmm5, (%edx) // Store destination pixels - -.LAlignDone: - addl %edi, %eax // Adjust pointers and pixel count - addl %edi, %edx - shrl $2, %edi - lddqu (%eax), %xmm1 // Pre-load new source pixels (after alignment) - subl %edi, %ecx - -.LAligned: // Destination is guaranteed to be 16 byte aligned - xorl %edi, %edi // Reset offset to zero - subl $8, %ecx // Decrease counter (Reserve four pixels for the cleanup) - testl $0xF, %eax // Check alignment of source pointer - jz .LAlignedLoop - - // Source not aligned to destination - //////////////////////////////////////////////////////////////////////////////// - .p2align 4 -.LUnalignedLoop: // Main loop for unaligned, handles eight pixels per iteration - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero00 - lddqu 16(%eax, %edi), %xmm2 // Pre-load four source pixels - jz .LAlphaZero00 - movdqa %xmm1, (%edx, %edi) // Store four destination pixels - -.LAlphaZero00: - ptest %xmm7, %xmm2 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero01 - lddqu 32(%eax, %edi), %xmm1 // Pre-load four source pixels - jz .LAlphaZero01 - movdqa %xmm2, 16(%edx, %edi) // Store four destination pixels - -.LAlphaZero01: - addl $32, %edi // Adjust offset and pixel count - subl $8, %ecx - jae .LUnalignedLoop - addl $8, %ecx // Adjust pixel count - jmp .LLoopCleanup0 - - .p2align 4 -.LAlphaNotOpaqueOrZero00: - movdqa (%edx, %edi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - lddqu 16(%eax, %edi), %xmm2 // Pre-load four source pixels - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm1 // Add source and destination pixels together - movdqa %xmm1, (%edx, %edi) // Store four destination pixels - - // Handle next four pixels - ptest %xmm7, %xmm2 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero01 - lddqu 32(%eax, %edi), %xmm1 // Pre-load four source pixels - jz .LAlphaZero02 - movdqa %xmm2, 16(%edx, %edi) // Store four destination pixels -.LAlphaZero02: - addl $32, %edi // Adjust offset and pixel count - subl $8, %ecx - jae .LUnalignedLoop - addl $8, %ecx // Adjust pixel count - jmp .LLoopCleanup0 - - .p2align 4 -.LAlphaNotOpaqueOrZero01: - movdqa 16(%edx, %edi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm2, xmm1) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - lddqu 32(%eax, %edi), %xmm1 // Pre-load four source pixels - addl $32, %edi - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm2 // Add source and destination pixels together - subl $8, %ecx - movdqa %xmm2, -16(%edx, %edi) // Store four destination pixels - jae .LUnalignedLoop - addl $8, %ecx // Adjust pixel count - - // Cleanup - handle pending pixels from loop -.LLoopCleanup0: - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero02 - jz .LAlphaZero03 - movdqa %xmm1, (%edx, %edi) // Store four destination pixels -.LAlphaZero03: - addl $16, %edi - subl $4, %ecx - js .LSmallRemaining // Reuse code from small loop - -.LRemain0: - lddqu (%eax, %edi), %xmm1 // Load four source pixels - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero02 - jz .LAlphaZero04 - movdqa %xmm1, (%edx, %edi) // Store four destination pixels -.LAlphaZero04: - addl $16, %edi - subl $4, %ecx - jmp .LSmallRemaining // Reuse code from small loop - -.LAlphaNotOpaqueOrZero02: - movdqa (%edx, %edi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - addl $16, %edi - subl $4, %ecx - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm1 // Add source and destination pixels together - movdqa %xmm1, -16(%edx, %edi) // Store four destination pixels - js .LSmallRemaining // Reuse code from small loop - jmp .LRemain0 - - // Source aligned to destination - //////////////////////////////////////////////////////////////////////////////// - .p2align 4 -.LAlignedLoop: // Main loop for aligned, handles eight pixels per iteration - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero10 - movdqa 16(%eax, %edi), %xmm2 // Pre-load four source pixels - jz .LAlphaZero10 - movdqa %xmm1, (%edx, %edi) // Store four destination pixels - -.LAlphaZero10: - ptest %xmm7, %xmm2 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero11 - movdqa 32(%eax, %edi), %xmm1 // Pre-load four source pixels - jz .LAlphaZero11 - movdqa %xmm2, 16(%edx, %edi) // Store four destination pixels - -.LAlphaZero11: - addl $32, %edi // Adjust offset and pixel count - subl $8, %ecx - jae .LAlignedLoop - addl $8, %ecx // Adjust pixel count - jmp .LLoopCleanup1 - - .p2align 4 -.LAlphaNotOpaqueOrZero10: - movdqa (%edx, %edi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - movdqa 16(%eax, %edi), %xmm2 // Pre-load four source pixels - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm1 // Add source and destination pixels together - movdqa %xmm1, (%edx, %edi) // Store four destination pixels - - // Handle next four pixels - ptest %xmm7, %xmm2 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero11 - movdqa 32(%eax, %edi), %xmm1 // Pre-load four source pixels - jz .LAlphaZero12 - movdqa %xmm2, 16(%edx, %edi) // Store four destination pixels -.LAlphaZero12: - addl $32, %edi // Adjust offset and pixel count - subl $8, %ecx - jae .LAlignedLoop - addl $8, %ecx // Adjust pixel count - jmp .LLoopCleanup1 - - .p2align 4 -.LAlphaNotOpaqueOrZero11: - movdqa 16(%edx, %edi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm2, xmm1) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - movdqa 32(%eax, %edi), %xmm1 // Pre-load four source pixels - - addl $32, %edi - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm2 // Add source and destination pixels together - subl $8, %ecx - movdqa %xmm2, -16(%edx, %edi) // Store four destination pixels - jae .LAlignedLoop - addl $8, %ecx // Adjust pixel count - - // Cleanup - handle pending pixels from loop -.LLoopCleanup1: - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero12 - jz .LAlphaZero13 - movdqa %xmm1, (%edx, %edi) // Store four destination pixels -.LAlphaZero13: - addl $16, %edi - subl $4, %ecx - js .LSmallRemaining // Reuse code from small loop - -.LRemain1: - movdqa (%eax, %edi), %xmm1 // Load four source pixels - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero12 - jz .LAlphaZero14 - movdqa %xmm1, (%edx, %edi) // Store four destination pixels -.LAlphaZero14: - addl $16, %edi - subl $4, %ecx - jmp .LSmallRemaining // Reuse code from small loop - -.LAlphaNotOpaqueOrZero12: - movdqa (%edx, %edi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - addl $16, %edi - subl $4, %ecx - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm1 // Add source and destination pixels together - movdqa %xmm1, -16(%edx, %edi) // Store four destination pixels - js .LSmallRemaining // Reuse code from small loop - jmp .LRemain1 - - .cfi_endproc -#ifndef __clang__ - .size S32A_Opaque_BlitRow32_SSE4_asm, .-S32A_Opaque_BlitRow32_SSE4_asm -#endif -#endif - -#endif // CRBUG_399842_FIXED diff --git a/src/opts/SkBlitRow_opts_SSE4_x64_asm.S b/src/opts/SkBlitRow_opts_SSE4_x64_asm.S deleted file mode 100644 index 9a754a635b..0000000000 --- a/src/opts/SkBlitRow_opts_SSE4_x64_asm.S +++ /dev/null @@ -1,472 +0,0 @@ -/* - * Copyright 2014 The Android Open Source Project - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#ifdef CRBUG_399842_FIXED - -#if defined(__clang__) || (defined(__GNUC__) && !defined(SK_BUILD_FOR_MAC)) - -#define EXTRACT_ALPHA(var1, var2) \ - movdqa %var1, %var2; /* Clone source pixels to extract alpha */\ - psrlw $8, %var2; /* Discard red and blue, leaving alpha and green */\ - pshufhw $0xF5, %var2, %var2; /* Repeat alpha for scaling (high) */\ - movdqa %xmm6, %xmm4; \ - pshuflw $0xF5, %var2, %var2; /* Repeat alpha for scaling (low) */\ - movdqa %xmm5, %xmm3; \ - psubw %var2, %xmm4 /* Finalize alpha calculations */ - -#define SCALE_PIXELS \ - psllw $8, %xmm5; /* Filter out red and blue components */\ - pmulhuw %xmm4, %xmm5; /* Scale red and blue */\ - psrlw $8, %xmm3; /* Filter out alpha and green components */\ - pmullw %xmm4, %xmm3 /* Scale alpha and green */ - - -/* - * void S32A_Opaque_BlitRow32_SSE4(SkPMColor* SK_RESTRICT dst, - * const SkPMColor* SK_RESTRICT src, - * int count, U8CPU alpha) - * - * This function is divided into six blocks: initialization, blit 4-15 pixels, - * blit 0-3 pixels, align destination for 16+ pixel blits, - * blit 16+ pixels with source unaligned, blit 16+ pixels with source aligned. - * There are some code reuse between the blocks. - * - * The primary optimization comes from checking the source pixels' alpha value. - * If the alpha is zero, the pixel can be skipped entirely. - * If the alpha is fully opaque, the pixel can be copied directly to the destination. - * According to collected statistics, these two cases are the most common. - * The main loop(s) uses pre-loading and unrolling in an attempt to reduce the - * memory latency worse-case. - */ - -#ifdef __clang__ - .text -#else - .section .text.sse4.2,"ax",@progbits - .type S32A_Opaque_BlitRow32_SSE4_asm, @function -#endif - .p2align 4 -#if defined(SK_BUILD_FOR_MAC) - .global _S32A_Opaque_BlitRow32_SSE4_asm - .private_extern _S32A_Opaque_BlitRow32_SSE4_asm -_S32A_Opaque_BlitRow32_SSE4_asm: -#else - .global S32A_Opaque_BlitRow32_SSE4_asm - .hidden S32A_Opaque_BlitRow32_SSE4_asm -S32A_Opaque_BlitRow32_SSE4_asm: -#endif - .cfi_startproc - prefetcht0 (%rsi) - movl %edx, %ecx // Pixel count - movq %rdi, %rdx // Destination pointer - movq %rsi, %rax // Source pointer - - // Setup SSE constants - movdqa .LAlphaCheckMask(%rip), %xmm7 // 0xFF000000 mask to check alpha - movdqa .LInverseAlphaCalc(%rip), %xmm6// 16-bit 256 to calculate inv. alpha - movdqa .LResultMergeMask(%rip), %xmm0 // 0x00FF00FF mask (Must be in xmm0 because of pblendvb) - - subl $4, %ecx // Check if we have only 0-3 pixels - js .LReallySmall - cmpl $11, %ecx // Do we have enough pixels to run the main loop? - ja .LBigBlit - - // Handle small blits (4-15 pixels) - //////////////////////////////////////////////////////////////////////////////// - xorq %rdi, %rdi // Reset offset to zero - -.LSmallLoop: - lddqu (%rax, %rdi), %xmm1 // Load four source pixels - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LSmallAlphaNotOpaqueOrZero - jz .LSmallAlphaZero - movdqu %xmm1, (%rdx, %rdi) // Store four destination pixels -.LSmallAlphaZero: - addq $16, %rdi - subl $4, %ecx // Check if there are four additional pixels, at least - jns .LSmallLoop - jmp .LSmallRemaining - - // Handle mixed alphas (calculate and scale) - .p2align 4 -.LSmallAlphaNotOpaqueOrZero: - lddqu (%rdx, %rdi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - addq $16, %rdi - subl $4, %ecx // Check if there are four additional pixels, at least - pblendvb %xmm5, %xmm3 // Mask in %xmm0, implicitly - paddb %xmm3, %xmm1 // Add source and destination pixels together - movdqu %xmm1, -16(%rdx, %rdi) // Store four destination pixels - jns .LSmallLoop - - // Handle the last 0-3 pixels (also used by the main loops) -.LSmallRemaining: - cmpl $-4, %ecx // Check if we are done - je .LSmallExit - sall $2, %ecx // Calculate offset for last pixels - movslq %ecx, %rcx - addq %rcx, %rdi - - lddqu (%rax, %rdi), %xmm1 // Load last four source pixels (overlapping) - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - jc .LSmallRemainingStoreAll// If all alphas are opaque, just store (overlapping) - jz .LSmallExit // If all alphas are zero, skip the pixels completely - - // Handle mixed alphas (calculate and scale) - lddqu (%rdx, %rdi), %xmm5 // Load last four destination pixels (overlapping) - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - - psllw $8, %xmm3 // Filter out red and blue components - pmulhuw %xmm4, %xmm3 // Scale red and blue - movdqa %xmm5, %xmm2 - psrlw $8, %xmm2 // Filter out alpha and green components - pmullw %xmm4, %xmm2 // Scale alpha and green - - cmpl $-8, %ecx // Check how many pixels should be written - pblendvb %xmm3, %xmm2 // Combine results (mask in %xmm0, implicitly) - paddb %xmm2, %xmm1 // Add source and destination pixels together - jb .LSmallPixelsLeft1 - ja .LSmallPixelsLeft3 // To avoid double-blending the overlapping pixels... - pblendw $0xF0, %xmm1, %xmm5 // Merge only the final two pixels to the destination - movdqu %xmm5, (%rdx, %rdi) // Store last two destination pixels -.LSmallExit: - ret - -.LSmallPixelsLeft1: - pblendw $0xC0, %xmm1, %xmm5 // Merge only the final pixel to the destination - movdqu %xmm5, (%rdx, %rdi) // Store last destination pixel - ret - -.LSmallPixelsLeft3: - pblendw $0xFC, %xmm1, %xmm5 // Merge only the final three pixels to the destination - movdqu %xmm5, (%rdx, %rdi) // Store last three destination pixels - ret - -.LSmallRemainingStoreAll: - movdqu %xmm1, (%rdx, %rdi) // Store last destination pixels (overwrite) - ret - - // Handle really small blits (0-3 pixels) - //////////////////////////////////////////////////////////////////////////////// -.LReallySmall: - addl $4, %ecx - jle .LReallySmallExit - pcmpeqd %xmm1, %xmm1 - cmpl $2, %ecx // Check how many pixels should be read - pinsrd $0x0, (%rax), %xmm1 // Load one source pixel - pinsrd $0x0, (%rdx), %xmm5 // Load one destination pixel - jb .LReallySmallCalc - pinsrd $0x1, 4(%rax), %xmm1 // Load second source pixel - pinsrd $0x1, 4(%rdx), %xmm5 // Load second destination pixel - je .LReallySmallCalc - pinsrd $0x2, 8(%rax), %xmm1 // Load third source pixel - pinsrd $0x2, 8(%rdx), %xmm5 // Load third destination pixel - -.LReallySmallCalc: - ptest %xmm7, %xmm1 // Check if all alphas are opaque - jc .LReallySmallStore // If all alphas are opaque, just store - - // Handle mixed alphas (calculate and scale) - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - - pand %xmm0, %xmm5 // Filter out red and blue components - pmullw %xmm4, %xmm5 // Scale red and blue - psrlw $8, %xmm3 // Filter out alpha and green components - pmullw %xmm4, %xmm3 // Scale alpha and green - - psrlw $8, %xmm5 // Combine results - pblendvb %xmm5, %xmm3 // Mask in %xmm0, implicitly - paddb %xmm3, %xmm1 // Add source and destination pixels together - -.LReallySmallStore: - cmpl $2, %ecx // Check how many pixels should be written - pextrd $0x0, %xmm1, (%rdx) // Store one destination pixel - jb .LReallySmallExit - pextrd $0x1, %xmm1, 4(%rdx) // Store second destination pixel - je .LReallySmallExit - pextrd $0x2, %xmm1, 8(%rdx) // Store third destination pixel -.LReallySmallExit: - ret - - // Handle bigger blit operations (16+ pixels) - //////////////////////////////////////////////////////////////////////////////// - .p2align 4 -.LBigBlit: - // Align destination? - testl $0xF, %edx - lddqu (%rax), %xmm1 // Pre-load four source pixels - jz .LAligned - - movq %rdx, %rdi // Calculate alignment of destination pointer - negq %rdi - andl $0xF, %edi - - // Handle 1-3 pixels to align destination - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - jz .LAlignDone // If all alphas are zero, just skip - lddqu (%rdx), %xmm5 // Load four destination pixels - jc .LAlignStore // If all alphas are opaque, just store - - // Handle mixed alphas (calculate and scale) - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - - psllw $8, %xmm3 // Filter out red and blue components - pmulhuw %xmm4, %xmm3 // Scale red and blue - movdqa %xmm5, %xmm2 - psrlw $8, %xmm2 // Filter out alpha and green components - pmullw %xmm4, %xmm2 // Scale alpha and green - - pblendvb %xmm3, %xmm2 // Combine results (mask in %xmm0, implicitly) - paddb %xmm2, %xmm1 // Add source and destination pixels together - -.LAlignStore: - cmpl $8, %edi // Check how many pixels should be written - jb .LAlignPixelsLeft1 - ja .LAlignPixelsLeft3 - pblendw $0x0F, %xmm1, %xmm5 // Blend two pixels - jmp .LAlignStorePixels - -.LAlignPixelsLeft1: - pblendw $0x03, %xmm1, %xmm5 // Blend one pixel - jmp .LAlignStorePixels - -.LAlignPixelsLeft3: - pblendw $0x3F, %xmm1, %xmm5 // Blend three pixels - -.LAlignStorePixels: - movdqu %xmm5, (%rdx) // Store destination pixels - -.LAlignDone: - addq %rdi, %rax // Adjust pointers and pixel count - addq %rdi, %rdx - shrq $2, %rdi - lddqu (%rax), %xmm1 // Pre-load new source pixels (after alignment) - subl %edi, %ecx - -.LAligned: // Destination is guaranteed to be 16 byte aligned - xorq %rdi, %rdi // Reset offset to zero - subl $8, %ecx // Decrease counter (Reserve four pixels for the cleanup) - testl $0xF, %eax // Check alignment of source pointer - jz .LAlignedLoop - - // Source not aligned to destination - //////////////////////////////////////////////////////////////////////////////// - .p2align 4 -.LUnalignedLoop: // Main loop for unaligned, handles eight pixels per iteration - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero00 - lddqu 16(%rax, %rdi), %xmm2 // Pre-load four source pixels - jz .LAlphaZero00 - movdqa %xmm1, (%rdx, %rdi) // Store four destination pixels - -.LAlphaZero00: - ptest %xmm7, %xmm2 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero01 - lddqu 32(%rax, %rdi), %xmm1 // Pre-load four source pixels - jz .LAlphaZero01 - movdqa %xmm2, 16(%rdx, %rdi) // Store four destination pixels - -.LAlphaZero01: - addq $32, %rdi // Adjust offset and pixel count - subl $8, %ecx - jae .LUnalignedLoop - addl $8, %ecx // Adjust pixel count - jmp .LLoopCleanup0 - - .p2align 4 -.LAlphaNotOpaqueOrZero00: - movdqa (%rdx, %rdi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - lddqu 16(%rax, %rdi), %xmm2 // Pre-load four source pixels - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm1 // Add source and destination pixels together - movdqa %xmm1, (%rdx, %rdi) // Store four destination pixels - - // Handle next four pixels - ptest %xmm7, %xmm2 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero01 - lddqu 32(%rax, %rdi), %xmm1 // Pre-load four source pixels - jz .LAlphaZero02 - movdqa %xmm2, 16(%rdx, %rdi) // Store four destination pixels -.LAlphaZero02: - addq $32, %rdi // Adjust offset and pixel count - subl $8, %ecx - jae .LUnalignedLoop - addl $8, %ecx // Adjust pixel count - jmp .LLoopCleanup0 - - .p2align 4 -.LAlphaNotOpaqueOrZero01: - movdqa 16(%rdx, %rdi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm2, xmm1) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - lddqu 32(%rax, %rdi), %xmm1 // Pre-load four source pixels - addq $32, %rdi - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm2 // Add source and destination pixels together - subl $8, %ecx - movdqa %xmm2, -16(%rdx, %rdi) // Store four destination pixels - jae .LUnalignedLoop - addl $8, %ecx // Adjust pixel count - - // Cleanup - handle pending pixels from loop -.LLoopCleanup0: - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero02 - jz .LAlphaZero03 - movdqa %xmm1, (%rdx, %rdi) // Store four destination pixels -.LAlphaZero03: - addq $16, %rdi - subl $4, %ecx - js .LSmallRemaining // Reuse code from small loop - -.LRemain0: - lddqu (%rax, %rdi), %xmm1 // Load four source pixels - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero02 - jz .LAlphaZero04 - movdqa %xmm1, (%rdx, %rdi) // Store four destination pixels -.LAlphaZero04: - addq $16, %rdi - subl $4, %ecx - jmp .LSmallRemaining // Reuse code from small loop - -.LAlphaNotOpaqueOrZero02: - movdqa (%rdx, %rdi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - addq $16, %rdi - subl $4, %ecx - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm1 // Add source and destination pixels together - movdqa %xmm1, -16(%rdx, %rdi) // Store four destination pixels - js .LSmallRemaining // Reuse code from small loop - jmp .LRemain0 - - // Source aligned to destination - //////////////////////////////////////////////////////////////////////////////// - .p2align 4 -.LAlignedLoop: // Main loop for aligned, handles eight pixels per iteration - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero10 - movdqa 16(%rax, %rdi), %xmm2 // Pre-load four source pixels - jz .LAlphaZero10 - movdqa %xmm1, (%rdx, %rdi) // Store four destination pixels - -.LAlphaZero10: - ptest %xmm7, %xmm2 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero11 - movdqa 32(%rax, %rdi), %xmm1 // Pre-load four source pixels - jz .LAlphaZero11 - movdqa %xmm2, 16(%rdx, %rdi) // Store four destination pixels - -.LAlphaZero11: - addq $32, %rdi // Adjust offset and pixel count - subl $8, %ecx - jae .LAlignedLoop - addl $8, %ecx // Adjust pixel count - jmp .LLoopCleanup1 - - .p2align 4 -.LAlphaNotOpaqueOrZero10: - movdqa (%rdx, %rdi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - movdqa 16(%rax, %rdi), %xmm2 // Pre-load four source pixels - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm1 // Add source and destination pixels together - movdqa %xmm1, (%rdx, %rdi) // Store four destination pixels - - // Handle next four pixels - ptest %xmm7, %xmm2 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero11 - movdqa 32(%rax, %rdi), %xmm1 // Pre-load four source pixels - jz .LAlphaZero12 - movdqa %xmm2, 16(%rdx, %rdi) // Store four destination pixels -.LAlphaZero12: - addq $32, %rdi // Adjust offset and pixel count - subl $8, %ecx - jae .LAlignedLoop - addl $8, %ecx // Adjust pixel count - jmp .LLoopCleanup1 - - .p2align 4 -.LAlphaNotOpaqueOrZero11: - movdqa 16(%rdx, %rdi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm2, xmm1) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - movdqa 32(%rax, %rdi), %xmm1 // Pre-load four source pixels - - addq $32, %rdi - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm2 // Add source and destination pixels together - subl $8, %ecx - movdqa %xmm2, -16(%rdx, %rdi) // Store four destination pixels - jae .LAlignedLoop - addl $8, %ecx // Adjust pixel count - - // Cleanup - handle four pending pixels from loop -.LLoopCleanup1: - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero12 - jz .LAlphaZero13 - movdqa %xmm1, (%rdx, %rdi) // Store four destination pixels -.LAlphaZero13: - addq $16, %rdi - subl $4, %ecx - js .LSmallRemaining // Reuse code from small loop - -.LRemain1: - movdqa (%rax, %rdi), %xmm1 // Pre-load four source pixels - ptest %xmm7, %xmm1 // Check if all alphas are zero or opaque - ja .LAlphaNotOpaqueOrZero12 - jz .LAlphaZero14 - movdqa %xmm1, (%rdx, %rdi) // Store four destination pixels -.LAlphaZero14: - addq $16, %rdi - subl $4, %ecx - jmp .LSmallRemaining // Reuse code from small loop - -.LAlphaNotOpaqueOrZero12: - movdqa (%rdx, %rdi), %xmm5 // Load four destination pixels - EXTRACT_ALPHA(xmm1, xmm2) // Extract and clone alpha value - SCALE_PIXELS // Scale pixels using alpha - - addq $16, %rdi - subl $4, %ecx - pblendvb %xmm5, %xmm3 // Combine results (mask in %xmm0, implicitly) - paddb %xmm3, %xmm1 // Add source and destination pixels together - movdqa %xmm1, -16(%rdx, %rdi) // Store four destination pixels - js .LSmallRemaining // Reuse code from small loop - jmp .LRemain1 - - .cfi_endproc -#ifndef __clang__ - .size S32A_Opaque_BlitRow32_SSE4_asm, .-S32A_Opaque_BlitRow32_SSE4_asm -#endif - - // Constants for SSE code -#ifndef __clang__ - .section .rodata -#endif - .p2align 4 -.LAlphaCheckMask: - .long 0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000 -.LInverseAlphaCalc: - .word 256, 256, 256, 256, 256, 256, 256, 256 -.LResultMergeMask: - .long 0x00FF00FF, 0x00FF00FF, 0x00FF00FF, 0x00FF00FF -#endif - -#endif // CRBUG_399842_FIXED diff --git a/src/opts/SkColor_opts_SSE2.h b/src/opts/SkColor_opts_SSE2.h index 970abb859b..feb1d98f8d 100644 --- a/src/opts/SkColor_opts_SSE2.h +++ b/src/opts/SkColor_opts_SSE2.h @@ -206,7 +206,14 @@ static inline __m128i SkPixel32ToPixel16_ToU16_SSE2(const __m128i& src_pixel1, return d_pixel; } -// Portable version SkBlendARGB32 is in SkColorPriv.h. +// Portable version is SkPMSrcOver in SkColorPriv.h. +static inline __m128i SkPMSrcOver_SSE2(const __m128i& src, const __m128i& dst) { + return _mm_add_epi32(src, + SkAlphaMulQ_SSE2(dst, _mm_sub_epi32(_mm_set1_epi32(256), + SkGetPackedA32_SSE2(src)))); +} + +// Portable version is SkBlendARGB32 in SkColorPriv.h. static inline __m128i SkBlendARGB32_SSE2(const __m128i& src, const __m128i& dst, const __m128i& aa) { __m128i src_scale = SkAlpha255To256_SSE2(aa); diff --git a/src/opts/opts_check_x86.cpp b/src/opts/opts_check_x86.cpp index 71107d8756..84a4913021 100644 --- a/src/opts/opts_check_x86.cpp +++ b/src/opts/opts_check_x86.cpp @@ -227,21 +227,17 @@ static SkBlitRow::Proc32 platform_32_procs_SSE2[] = { S32A_Blend_BlitRow32_SSE2, // S32A_Blend, }; -#if defined(SK_ATT_ASM_SUPPORTED) static SkBlitRow::Proc32 platform_32_procs_SSE4[] = { NULL, // S32_Opaque, S32_Blend_BlitRow32_SSE2, // S32_Blend, - S32A_Opaque_BlitRow32_SSE4_asm, // S32A_Opaque + S32A_Opaque_BlitRow32_SSE4, // S32A_Opaque S32A_Blend_BlitRow32_SSE2, // S32A_Blend, }; -#endif SkBlitRow::Proc32 SkBlitRow::PlatformProcs32(unsigned flags) { -#if defined(SK_ATT_ASM_SUPPORTED) if (supports_simd(SK_CPU_SSE_LEVEL_SSE41)) { return platform_32_procs_SSE4[flags]; } else -#endif if (supports_simd(SK_CPU_SSE_LEVEL_SSE2)) { return platform_32_procs_SSE2[flags]; } else { |