Common Source Code Project for Qt (a.k.a for FM-7).
| 修訂 | 6e6f0a63f552ff529e5123b898977636bcfda6b9 (tree) |
|---|---|
| 時間 | 2019-03-20 22:25:03 |
| 作者 | K.Ohta <whatisthis.sowhat@gmai...> |
| Commiter | K.Ohta |
[VM][COMMON] Delete unneeded builtin_assume_aligned().MinGW32 build works built with "-msse2 -O3".
source/src/common.cpp (diff) source/src/vm/bmjr/memory.cpp (diff) source/src/vm/fm7/vram.cpp (diff) source/src/vm/fmtowns/towns_vram.cpp (diff)| @@ -593,13 +593,13 @@ void DLL_PREFIX ConvertByteToPackedPixelByColorTable2(uint8_t *src, scrntype_t* | ||
| 593 | 593 | __DECL_ALIGNED(32) scrntype_vec8_t tmpd; |
| 594 | 594 | __DECL_ALIGNED(32) scrntype_vec8_t tmpdd; |
| 595 | 595 | __DECL_ALIGNED(32) scrntype_vec8_t colors; |
| 596 | - scrntype_vec8_t* vt = (scrntype_vec8_t*)__builtin_assume_aligned(&(tbl->plane_table[0]), sizeof(scrntype_vec8_t)); | |
| 596 | + scrntype_vec8_t* vt = (scrntype_vec8_t*)(&(tbl->plane_table[0])); | |
| 597 | 597 | |
| 598 | 598 | uintptr_t disalign = (uintptr_t)dst; |
| 599 | 599 | disalign = disalign & (sizeof(scrntype_vec8_t) - 1); //Is align by 128bits or 256bytes? |
| 600 | 600 | if(disalign == 0) { |
| 601 | 601 | // Yes. |
| 602 | - scrntype_vec8_t *vdst = (scrntype_vec8_t*)__builtin_assume_aligned(dst, sizeof(scrntype_vec8_t)); | |
| 602 | + scrntype_vec8_t *vdst = (scrntype_vec8_t*)dst; | |
| 603 | 603 | __DECL_VECTORIZED_LOOP |
| 604 | 604 | for(int i = 0; i < bytes; i++) { |
| 605 | 605 | tmpd.v = vt[src[i]].v; |
| @@ -657,7 +657,7 @@ void DLL_PREFIX ConvertByteToSparceUint16(uint8_t *src, uint16_t* dst, int bytes | ||
| 657 | 657 | { |
| 658 | 658 | |
| 659 | 659 | __DECL_ALIGNED(16) uint16_vec8_t tmpd; |
| 660 | - uint16_vec8_t* vt = (uint16_vec8_t*)__builtin_assume_aligned(&(tbl->plane_table[0]), sizeof(uint16_vec8_t)); | |
| 660 | + uint16_vec8_t* vt = (uint16_vec8_t*)(&(tbl->plane_table[0])); | |
| 661 | 661 | |
| 662 | 662 | __DECL_ALIGNED(16) uint16_vec8_t __masks; |
| 663 | 663 |
| @@ -669,7 +669,7 @@ __DECL_VECTORIZED_LOOP | ||
| 669 | 669 | disalign = disalign & 0x0f; //Is align by 128bits? |
| 670 | 670 | if(disalign == 0) { |
| 671 | 671 | // Yes. |
| 672 | - uint16_vec8_t *vdst = (uint16_vec8_t*)__builtin_assume_aligned(dst, sizeof(uint16_vec8_t)); | |
| 672 | + uint16_vec8_t *vdst = (uint16_vec8_t*)dst; | |
| 673 | 673 | __DECL_VECTORIZED_LOOP |
| 674 | 674 | for(int i = 0; i < bytes; i++) { |
| 675 | 675 | tmpd.v = vt[src[i]].v; |
| @@ -699,7 +699,7 @@ void DLL_PREFIX ConvertByteToSparceUint8(uint8_t *src, uint16_t* dst, int bytes, | ||
| 699 | 699 | { |
| 700 | 700 | |
| 701 | 701 | __DECL_ALIGNED(16) uint16_vec8_t tmpd; |
| 702 | - uint16_vec8_t* vt = (uint16_vec8_t*)__builtin_assume_aligned(&(tbl->plane_table[0]), sizeof(uint16_vec8_t)); | |
| 702 | + uint16_vec8_t* vt = (uint16_vec8_t*)(&(tbl->plane_table[0])); | |
| 703 | 703 | |
| 704 | 704 | __DECL_ALIGNED(16) uint16_vec8_t __masks; |
| 705 | 705 | __DECL_ALIGNED(16) uint8_vec8_t tmpdd; |
| @@ -712,7 +712,7 @@ __DECL_VECTORIZED_LOOP | ||
| 712 | 712 | disalign = disalign & 0x07; //Is align by 128bits? |
| 713 | 713 | if(disalign == 0) { |
| 714 | 714 | // Yes. |
| 715 | - uint8_vec8_t *vdst = (uint8_vec8_t*)__builtin_assume_aligned(dst, sizeof(uint8_vec8_t)); | |
| 715 | + uint8_vec8_t *vdst = (uint8_vec8_t*)dst; | |
| 716 | 716 | __DECL_VECTORIZED_LOOP |
| 717 | 717 | for(int i = 0; i < bytes; i++) { |
| 718 | 718 | tmpd.v = vt[src[i]].v; |
| @@ -745,13 +745,13 @@ void DLL_PREFIX ConvertByteToPackedPixelByColorTable(uint8_t *src, scrntype_t* d | ||
| 745 | 745 | |
| 746 | 746 | __DECL_ALIGNED(16) uint16_vec8_t tmpd; |
| 747 | 747 | __DECL_ALIGNED(32) scrntype_vec8_t tmpdd; |
| 748 | - uint16_vec8_t* vt = (uint16_vec8_t*)__builtin_assume_aligned(&(tbl->plane_table[0]), sizeof(uint16_vec8_t)); | |
| 748 | + uint16_vec8_t* vt = (uint16_vec8_t*)(&(tbl->plane_table[0])); | |
| 749 | 749 | |
| 750 | 750 | uintptr_t disalign = (uintptr_t)dst; |
| 751 | 751 | disalign = disalign & 0x0f; //Is align by 128bits? |
| 752 | 752 | if(disalign == 0) { |
| 753 | 753 | // Yes. |
| 754 | - scrntype_vec8_t *vdst = (scrntype_vec8_t*)__builtin_assume_aligned(dst, sizeof(scrntype_vec8_t)); | |
| 754 | + scrntype_vec8_t *vdst = (scrntype_vec8_t*)dst; | |
| 755 | 755 | __DECL_VECTORIZED_LOOP |
| 756 | 756 | for(int i = 0; i < bytes; i++) { |
| 757 | 757 | tmpd.v = vt[src[i]].v; |
| @@ -940,7 +940,7 @@ __DECL_VECTORIZED_LOOP | ||
| 940 | 940 | const bool is_render[4] = { src->is_render[0], src->is_render[1], src->is_render[2], src->is_render[3] }; |
| 941 | 941 | __DECL_ALIGNED(16) uint16_vec8_t tmpd; |
| 942 | 942 | __DECL_ALIGNED(32) scrntype_vec8_t tmp_dd; |
| 943 | - scrntype_vec8_t* vdp = (scrntype_vec8_t*)__builtin_assume_aligned(dst, sizeof(scrntype_vec8_t)); | |
| 943 | + scrntype_vec8_t* vdp = (scrntype_vec8_t*)dst; | |
| 944 | 944 | |
| 945 | 945 | x = src->begin_pos; |
| 946 | 946 | uint32_t xn = x; |
| @@ -970,7 +970,7 @@ __DECL_VECTORIZED_LOOP | ||
| 970 | 970 | static const int shift_factor = 3; |
| 971 | 971 | #endif |
| 972 | 972 | __DECL_ALIGNED(32) scrntype_vec8_t sline; |
| 973 | - scrntype_vec8_t* vdp2 = (scrntype_vec8_t*)__builtin_assume_aligned(dst2, sizeof(scrntype_vec8_t)); | |
| 973 | + scrntype_vec8_t* vdp2 = (scrntype_vec8_t*)dst2; | |
| 974 | 974 | __DECL_VECTORIZED_LOOP |
| 975 | 975 | for(int i = 0; i < 8; i++) { |
| 976 | 976 | sline.w[i] = (scrntype_t)RGBA_COLOR(31, 31, 31, 255); |
| @@ -1040,7 +1040,7 @@ __DECL_VECTORIZED_LOOP | ||
| 1040 | 1040 | const bool is_render[4] = { src->is_render[0], src->is_render[1], src->is_render[2], src->is_render[3] }; |
| 1041 | 1041 | __DECL_ALIGNED(16) uint16_vec8_t tmpd; |
| 1042 | 1042 | __DECL_ALIGNED(32) scrntype_vec8_t tmp_dd; |
| 1043 | - scrntype_vec8_t* vdp = (scrntype_vec8_t*)__builtin_assume_aligned(dst, sizeof(scrntype_vec8_t)); | |
| 1043 | + scrntype_vec8_t* vdp = (scrntype_vec8_t*)dst; | |
| 1044 | 1044 | |
| 1045 | 1045 | x = src->begin_pos; |
| 1046 | 1046 | if(dst2 == NULL) { |
| @@ -1069,7 +1069,7 @@ __DECL_VECTORIZED_LOOP | ||
| 1069 | 1069 | static const int shift_factor = 3; |
| 1070 | 1070 | #endif |
| 1071 | 1071 | __DECL_ALIGNED(32) scrntype_vec8_t sline; |
| 1072 | - scrntype_vec8_t* vdp2 = (scrntype_vec8_t*)__builtin_assume_aligned(dst2, sizeof(scrntype_vec8_t)); | |
| 1072 | + scrntype_vec8_t* vdp2 = (scrntype_vec8_t*)dst2; | |
| 1073 | 1073 | __DECL_VECTORIZED_LOOP |
| 1074 | 1074 | for(int i = 0; i < 8; i++) { |
| 1075 | 1075 | sline.w[i] = (scrntype_t)RGBA_COLOR(31, 31, 31, 255); |
| @@ -366,7 +366,7 @@ void MEMORY::draw_screen() | ||
| 366 | 366 | dest[6] = (pat & 0x02) ? fore : back; |
| 367 | 367 | dest[7] = (pat & 0x01) ? fore : back; |
| 368 | 368 | #else |
| 369 | - scrntype_vec8_t* vdest = (scrntype_vec8_t*)__builtin_assume_aligned(dest, sizeof(scrntype_vec8_t)); | |
| 369 | + scrntype_vec8_t* vdest = (scrntype_vec8_t*)dest; | |
| 370 | 370 | *vdest = ConvertByteToMonochromePackedPixel(pat, &bit_table, fore, back); |
| 371 | 371 | #endif |
| 372 | 372 | } |
| @@ -403,7 +403,7 @@ void MEMORY::draw_screen() | ||
| 403 | 403 | dest[6] = (pat & 0x02) ? fore : back; |
| 404 | 404 | dest[7] = (pat & 0x01) ? fore : back; |
| 405 | 405 | #else |
| 406 | - scrntype_vec8_t* vdest = (scrntype_vec8_t*)__builtin_assume_aligned(dest, sizeof(scrntype_vec8_t)); | |
| 406 | + scrntype_vec8_t* vdest = (scrntype_vec8_t*)dest; | |
| 407 | 407 | *vdest = ConvertByteToMonochromePackedPixel(pat, &bit_table, fore, back); |
| 408 | 408 | #endif |
| 409 | 409 | } |
| @@ -669,8 +669,8 @@ void DISPLAY::CopyDrawnData(scrntype_t* src, scrntype_t* dst, int width, bool sc | ||
| 669 | 669 | #else // 24bit |
| 670 | 670 | static const int shift_factor = 3; |
| 671 | 671 | #endif |
| 672 | - scrntype_vec8_t* vsrc = (scrntype_vec8_t*)__builtin_assume_aligned(src, sizeof(scrntype_vec8_t)); | |
| 673 | - scrntype_vec8_t* vdst = (scrntype_vec8_t*)__builtin_assume_aligned(dst, sizeof(scrntype_vec8_t)); | |
| 672 | + scrntype_vec8_t* vsrc = (scrntype_vec8_t*)src; | |
| 673 | + scrntype_vec8_t* vdst = (scrntype_vec8_t*)dst; | |
| 674 | 674 | __DECL_ALIGNED(32) scrntype_vec8_t tmp_dd; |
| 675 | 675 | __DECL_ALIGNED(32) scrntype_vec8_t sline; |
| 676 | 676 |
| @@ -745,10 +745,10 @@ void DISPLAY::GETVRAM_1_400L(int yoff, scrntype_t *p) | ||
| 745 | 745 | if(p == NULL) return; |
| 746 | 746 | yoff_d = yoff & 0x7fff; |
| 747 | 747 | pixel = gvram_shadow[yoff_d]; |
| 748 | - uint16_vec8_t *ppx = (uint16_vec8_t *)__builtin_assume_aligned(&(bit_trans_table_0[pixel][0]), 16); | |
| 748 | + uint16_vec8_t *ppx = (uint16_vec8_t *)(&(bit_trans_table_0[pixel][0])); | |
| 749 | 749 | __DECL_ALIGNED(16) uint16_vec8_t tmp_d; |
| 750 | 750 | __DECL_ALIGNED(32) scrntype_vec8_t tmp_dd; |
| 751 | - scrntype_vec8_t *vp = (scrntype_vec8_t *)__builtin_assume_aligned(p, sizeof(scrntype_vec8_t)); | |
| 751 | + scrntype_vec8_t *vp = (scrntype_vec8_t *)p; | |
| 752 | 752 | |
| 753 | 753 | tmp_d.v = ppx->v; |
| 754 | 754 | tmp_d.v = tmp_d.v >> 5; |
| @@ -768,10 +768,10 @@ void DISPLAY::GETVRAM_1_400L_GREEN(int yoff, scrntype_t *p) | ||
| 768 | 768 | if(p == NULL) return; |
| 769 | 769 | yoff_d = yoff & 0x7fff; |
| 770 | 770 | pixel = gvram_shadow[yoff_d]; |
| 771 | - uint16_vec8_t *ppx = (uint16_vec8_t *)__builtin_assume_aligned(&(bit_trans_table_0[pixel][0]), 16); | |
| 771 | + uint16_vec8_t *ppx = (uint16_vec8_t *)(&(bit_trans_table_0[pixel][0])); | |
| 772 | 772 | __DECL_ALIGNED(16) uint16_vec8_t tmp_d; |
| 773 | 773 | __DECL_ALIGNED(32) scrntype_vec8_t tmp_dd; |
| 774 | - scrntype_vec8_t *vp = (scrntype_vec8_t *)__builtin_assume_aligned(p, sizeof(scrntype_vec8_t)); | |
| 774 | + scrntype_vec8_t *vp = (scrntype_vec8_t *)p; | |
| 775 | 775 | |
| 776 | 776 | tmp_d.v = ppx->v; |
| 777 | 777 | tmp_d.v = tmp_d.v >> 5; |
| @@ -844,29 +844,29 @@ void DISPLAY::GETVRAM_4096(int yoff, scrntype_t *p, scrntype_t *px, | ||
| 844 | 844 | __DECL_ALIGNED(16) uint16_vec8_t tmp_g, tmp_r, tmp_b; |
| 845 | 845 | __v8hi *vp0, *vp1, *vp2, *vp3; |
| 846 | 846 | // G |
| 847 | - vp0 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_0[gg[0]][0]), 16); | |
| 848 | - vp1 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_1[gg[1]][0]), 16); | |
| 849 | - vp2 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_2[gg[2]][0]), 16); | |
| 850 | - vp3 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_3[gg[3]][0]), 16); | |
| 847 | + vp0 = (__v8hi*)(&(bit_trans_table_0[gg[0]][0])); | |
| 848 | + vp1 = (__v8hi*)(&(bit_trans_table_1[gg[1]][0])); | |
| 849 | + vp2 = (__v8hi*)(&(bit_trans_table_2[gg[2]][0])); | |
| 850 | + vp3 = (__v8hi*)(&(bit_trans_table_3[gg[3]][0])); | |
| 851 | 851 | tmp_g.v = *vp0; |
| 852 | 852 | tmp_g.v = tmp_g.v | *vp1; |
| 853 | 853 | tmp_g.v = tmp_g.v | *vp2; |
| 854 | 854 | tmp_g.v = tmp_g.v | *vp3; |
| 855 | 855 | // R |
| 856 | - vp0 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_0[rr[0]][0]), 16); | |
| 857 | - vp1 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_1[rr[1]][0]), 16); | |
| 858 | - vp2 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_2[rr[2]][0]), 16); | |
| 859 | - vp3 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_3[rr[3]][0]), 16); | |
| 856 | + vp0 = (__v8hi*)(&(bit_trans_table_0[rr[0]][0])); | |
| 857 | + vp1 = (__v8hi*)(&(bit_trans_table_1[rr[1]][0])); | |
| 858 | + vp2 = (__v8hi*)(&(bit_trans_table_2[rr[2]][0])); | |
| 859 | + vp3 = (__v8hi*)(&(bit_trans_table_3[rr[3]][0])); | |
| 860 | 860 | tmp_r.v = *vp0; |
| 861 | 861 | tmp_r.v = tmp_r.v | *vp1; |
| 862 | 862 | tmp_r.v = tmp_r.v | *vp2; |
| 863 | 863 | tmp_r.v = tmp_r.v | *vp3; |
| 864 | 864 | |
| 865 | 865 | // B |
| 866 | - vp0 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_0[bb[0]][0]), 16); | |
| 867 | - vp1 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_1[bb[1]][0]), 16); | |
| 868 | - vp2 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_2[bb[2]][0]), 16); | |
| 869 | - vp3 = (__v8hi*)__builtin_assume_aligned(&(bit_trans_table_3[bb[3]][0]), 16); | |
| 866 | + vp0 = (__v8hi*)(&(bit_trans_table_0[bb[0]][0])); | |
| 867 | + vp1 = (__v8hi*)(&(bit_trans_table_1[bb[1]][0])); | |
| 868 | + vp2 = (__v8hi*)(&(bit_trans_table_2[bb[2]][0])); | |
| 869 | + vp3 = (__v8hi*)(&(bit_trans_table_3[bb[3]][0])); | |
| 870 | 870 | tmp_b.v = *vp0; |
| 871 | 871 | tmp_b.v = tmp_b.v | *vp1; |
| 872 | 872 | tmp_b.v = tmp_b.v | *vp2; |
| @@ -881,8 +881,8 @@ void DISPLAY::GETVRAM_4096(int yoff, scrntype_t *p, scrntype_t *px, | ||
| 881 | 881 | pixels.v = pixels.v & *mp; |
| 882 | 882 | |
| 883 | 883 | |
| 884 | - scrntype_vec8_t *vp = (scrntype_vec8_t*)__builtin_assume_aligned(p, sizeof(scrntype_vec8_t)); | |
| 885 | - scrntype_vec8_t *dp = (scrntype_vec8_t*)__builtin_assume_aligned(tmp_dd, sizeof(scrntype_vec8_t)); | |
| 884 | + scrntype_vec8_t *vp = (scrntype_vec8_t*)p; | |
| 885 | + scrntype_vec8_t *dp = (scrntype_vec8_t*)tmp_dd; | |
| 886 | 886 | #if !defined(FIXED_FRAMEBUFFER_SIZE) |
| 887 | 887 | __DECL_VECTORIZED_LOOP |
| 888 | 888 | for(int i = 0; i < 8; i++) { |
| @@ -894,7 +894,7 @@ __DECL_VECTORIZED_LOOP | ||
| 894 | 894 | for(int i = 0; i < 8; i++) { |
| 895 | 895 | tmp_dd[i * 2] = tmp_dd[i * 2 + 1] = analog_palette_pixel[pixels.w[i]];; |
| 896 | 896 | } |
| 897 | - scrntype_vec8_t *vpx = (scrntype_vec8_t*)__builtin_assume_aligned(px, sizeof(scrntype_vec8_t)); | |
| 897 | + scrntype_vec8_t *vpx = (scrntype_vec8_t*)px; | |
| 898 | 898 | __DECL_ALIGNED(32) scrntype_vec8_t vmask; |
| 899 | 899 | __DECL_VECTORIZED_LOOP |
| 900 | 900 | for(int i = 0; i < 2; i++) { |
| @@ -978,12 +978,12 @@ void DISPLAY::GETVRAM_256k(int yoff, scrntype_t *p, scrntype_t *px, bool scan_li | ||
| 978 | 978 | bb[4] = gvram_shadow[yoff_d1 + 0x18000]; |
| 979 | 979 | bb[5] = gvram_shadow[yoff_d1 + 0x1a000]; |
| 980 | 980 | |
| 981 | - vp0 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_0[bb[0]][0]), 16); | |
| 982 | - vp1 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_1[bb[1]][0]), 16); | |
| 983 | - vp2 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_2[bb[2]][0]), 16); | |
| 984 | - vp3 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_3[bb[3]][0]), 16); | |
| 985 | - vp4 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_4[bb[4]][0]), 16); | |
| 986 | - vp5 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_5[bb[5]][0]), 16); | |
| 981 | + vp0 = (uint16_vec8_t*)(&(bit_trans_table_0[bb[0]][0])); | |
| 982 | + vp1 = (uint16_vec8_t*)(&(bit_trans_table_1[bb[1]][0])); | |
| 983 | + vp2 = (uint16_vec8_t*)(&(bit_trans_table_2[bb[2]][0])); | |
| 984 | + vp3 = (uint16_vec8_t*)(&(bit_trans_table_3[bb[3]][0])); | |
| 985 | + vp4 = (uint16_vec8_t*)(&(bit_trans_table_4[bb[4]][0])); | |
| 986 | + vp5 = (uint16_vec8_t*)(&(bit_trans_table_5[bb[5]][0])); | |
| 987 | 987 | _btmp.v = vp0->v; |
| 988 | 988 | _btmp.v = _btmp.v | vp1->v; |
| 989 | 989 | _btmp.v = _btmp.v | vp2->v; |
| @@ -1008,12 +1008,12 @@ __DECL_VECTORIZED_LOOP | ||
| 1008 | 1008 | rr[4] = gvram_shadow[yoff_d1 + 0x1c000]; |
| 1009 | 1009 | rr[5] = gvram_shadow[yoff_d1 + 0x1e000]; |
| 1010 | 1010 | |
| 1011 | - vp0 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_0[rr[0]][0]), 16); | |
| 1012 | - vp1 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_1[rr[1]][0]), 16); | |
| 1013 | - vp2 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_2[rr[2]][0]), 16); | |
| 1014 | - vp3 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_3[rr[3]][0]), 16); | |
| 1015 | - vp4 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_4[rr[4]][0]), 16); | |
| 1016 | - vp5 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_5[rr[5]][0]), 16); | |
| 1011 | + vp0 = (uint16_vec8_t*)(&(bit_trans_table_0[rr[0]][0])); | |
| 1012 | + vp1 = (uint16_vec8_t*)(&(bit_trans_table_1[rr[1]][0])); | |
| 1013 | + vp2 = (uint16_vec8_t*)(&(bit_trans_table_2[rr[2]][0])); | |
| 1014 | + vp3 = (uint16_vec8_t*)(&(bit_trans_table_3[rr[3]][0])); | |
| 1015 | + vp4 = (uint16_vec8_t*)(&(bit_trans_table_4[rr[4]][0])); | |
| 1016 | + vp5 = (uint16_vec8_t*)(&(bit_trans_table_5[rr[5]][0])); | |
| 1017 | 1017 | _rtmp.v = vp0->v; |
| 1018 | 1018 | _rtmp.v = _rtmp.v | vp1->v; |
| 1019 | 1019 | _rtmp.v = _rtmp.v | vp2->v; |
| @@ -1038,12 +1038,12 @@ __DECL_VECTORIZED_LOOP | ||
| 1038 | 1038 | gg[4] = gvram_shadow[yoff_d1 + 0x20000]; |
| 1039 | 1039 | gg[5] = gvram_shadow[yoff_d1 + 0x22000]; |
| 1040 | 1040 | |
| 1041 | - vp0 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_0[gg[0]][0]), 16); | |
| 1042 | - vp1 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_1[gg[1]][0]), 16); | |
| 1043 | - vp2 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_2[gg[2]][0]), 16); | |
| 1044 | - vp3 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_3[gg[3]][0]), 16); | |
| 1045 | - vp4 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_4[gg[4]][0]), 16); | |
| 1046 | - vp5 = (uint16_vec8_t*)__builtin_assume_aligned(&(bit_trans_table_5[gg[5]][0]), 16); | |
| 1041 | + vp0 = (uint16_vec8_t*)(&(bit_trans_table_0[gg[0]][0])); | |
| 1042 | + vp1 = (uint16_vec8_t*)(&(bit_trans_table_1[gg[1]][0])); | |
| 1043 | + vp2 = (uint16_vec8_t*)(&(bit_trans_table_2[gg[2]][0])); | |
| 1044 | + vp3 = (uint16_vec8_t*)(&(bit_trans_table_3[gg[3]][0])); | |
| 1045 | + vp4 = (uint16_vec8_t*)(&(bit_trans_table_4[gg[4]][0])); | |
| 1046 | + vp5 = (uint16_vec8_t*)(&(bit_trans_table_5[gg[5]][0])); | |
| 1047 | 1047 | _gtmp.v = vp0->v; |
| 1048 | 1048 | _gtmp.v = _gtmp.v | vp1->v; |
| 1049 | 1049 | _gtmp.v = _gtmp.v | vp2->v; |
| @@ -1057,7 +1057,7 @@ __DECL_VECTORIZED_LOOP | ||
| 1057 | 1057 | } |
| 1058 | 1058 | } |
| 1059 | 1059 | |
| 1060 | - scrntype_vec8_t* vpp = (scrntype_vec8_t*)__builtin_assume_aligned(p, sizeof(scrntype_vec8_t)); | |
| 1060 | + scrntype_vec8_t* vpp = (scrntype_vec8_t*)p; | |
| 1061 | 1061 | scrntype_vec8_t* dp = (scrntype_vec8_t*)tmp_dd; |
| 1062 | 1062 | #if !defined(FIXED_FRAMEBUFFER_SIZE) |
| 1063 | 1063 | __DECL_VECTORIZED_LOOP |
| @@ -1075,7 +1075,7 @@ __DECL_VECTORIZED_LOOP | ||
| 1075 | 1075 | for(int i = 0; i < 2; i++) { |
| 1076 | 1076 | vpp[i].v = dp[i].v; |
| 1077 | 1077 | } |
| 1078 | - scrntype_vec8_t* vpx = (scrntype_vec8_t*)__builtin_assume_aligned(px, sizeof(scrntype_vec8_t)); | |
| 1078 | + scrntype_vec8_t* vpx = (scrntype_vec8_t*)px; | |
| 1079 | 1079 | if(scan_line) { |
| 1080 | 1080 | /* Fancy scanline */ |
| 1081 | 1081 | __DECL_VECTORIZED_LOOP |
| @@ -537,7 +537,7 @@ void TOWNS_CRTC::render_line_256_boundary(int layer, scrntype_t *framebuffer, ui | ||
| 537 | 537 | int nwords = (int)words / 8; |
| 538 | 538 | int ip; |
| 539 | 539 | __DECL_ALIGNED(16) uint8_t src[8]; |
| 540 | - scrntype_t *pdst = __builtin_assume_aligned(framebuffer, sizeof(scrntype_t)); | |
| 540 | + scrntype_t *pdst = framebuffer; | |
| 541 | 541 | uint8_t *pp = (uint8_t *)vramptr; |
| 542 | 542 | |
| 543 | 543 | if(framebuffer == NULL) return; |
Fork