wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 1083238: Remove SIMD shuffle masks; r=till

Browse Source
This commit is contained in:
Benjamin Bouvier 2014-10-17 12:22:26 +02:00
parent 3362cff25c
commit bdddd3b100
2 changed files with 0 additions and 541 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

267
js/src/builtin/SIMD.cpp
View File

@ -368,270 +368,6 @@ const Class SIMDObject::class_ = {
nullptr
};
static JSConstIntegerSpec SHUFFLE_MASKS[] = {
{"XXXX", 0x0},
{"XXXY", 0x40},
{"XXXZ", 0x80},
{"XXXW", 0xC0},
{"XXYX", 0x10},
{"XXYY", 0x50},
{"XXYZ", 0x90},
{"XXYW", 0xD0},
{"XXZX", 0x20},
{"XXZY", 0x60},
{"XXZZ", 0xA0},
{"XXZW", 0xE0},
{"XXWX", 0x30},
{"XXWY", 0x70},
{"XXWZ", 0xB0},
{"XXWW", 0xF0},
{"XYXX", 0x4},
{"XYXY", 0x44},
{"XYXZ", 0x84},
{"XYXW", 0xC4},
{"XYYX", 0x14},
{"XYYY", 0x54},
{"XYYZ", 0x94},
{"XYYW", 0xD4},
{"XYZX", 0x24},
{"XYZY", 0x64},
{"XYZZ", 0xA4},
{"XYZW", 0xE4},
{"XYWX", 0x34},
{"XYWY", 0x74},
{"XYWZ", 0xB4},
{"XYWW", 0xF4},
{"XZXX", 0x8},
{"XZXY", 0x48},
{"XZXZ", 0x88},
{"XZXW", 0xC8},
{"XZYX", 0x18},
{"XZYY", 0x58},
{"XZYZ", 0x98},
{"XZYW", 0xD8},
{"XZZX", 0x28},
{"XZZY", 0x68},
{"XZZZ", 0xA8},
{"XZZW", 0xE8},
{"XZWX", 0x38},
{"XZWY", 0x78},
{"XZWZ", 0xB8},
{"XZWW", 0xF8},
{"XWXX", 0xC},
{"XWXY", 0x4C},
{"XWXZ", 0x8C},
{"XWXW", 0xCC},
{"XWYX", 0x1C},
{"XWYY", 0x5C},
{"XWYZ", 0x9C},
{"XWYW", 0xDC},
{"XWZX", 0x2C},
{"XWZY", 0x6C},
{"XWZZ", 0xAC},
{"XWZW", 0xEC},
{"XWWX", 0x3C},
{"XWWY", 0x7C},
{"XWWZ", 0xBC},
{"XWWW", 0xFC},
{"YXXX", 0x1},
{"YXXY", 0x41},
{"YXXZ", 0x81},
{"YXXW", 0xC1},
{"YXYX", 0x11},
{"YXYY", 0x51},
{"YXYZ", 0x91},
{"YXYW", 0xD1},
{"YXZX", 0x21},
{"YXZY", 0x61},
{"YXZZ", 0xA1},
{"YXZW", 0xE1},
{"YXWX", 0x31},
{"YXWY", 0x71},
{"YXWZ", 0xB1},
{"YXWW", 0xF1},
{"YYXX", 0x5},
{"YYXY", 0x45},
{"YYXZ", 0x85},
{"YYXW", 0xC5},
{"YYYX", 0x15},
{"YYYY", 0x55},
{"YYYZ", 0x95},
{"YYYW", 0xD5},
{"YYZX", 0x25},
{"YYZY", 0x65},
{"YYZZ", 0xA5},
{"YYZW", 0xE5},
{"YYWX", 0x35},
{"YYWY", 0x75},
{"YYWZ", 0xB5},
{"YYWW", 0xF5},
{"YZXX", 0x9},
{"YZXY", 0x49},
{"YZXZ", 0x89},
{"YZXW", 0xC9},
{"YZYX", 0x19},
{"YZYY", 0x59},
{"YZYZ", 0x99},
{"YZYW", 0xD9},
{"YZZX", 0x29},
{"YZZY", 0x69},
{"YZZZ", 0xA9},
{"YZZW", 0xE9},
{"YZWX", 0x39},
{"YZWY", 0x79},
{"YZWZ", 0xB9},
{"YZWW", 0xF9},
{"YWXX", 0xD},
{"YWXY", 0x4D},
{"YWXZ", 0x8D},
{"YWXW", 0xCD},
{"YWYX", 0x1D},
{"YWYY", 0x5D},
{"YWYZ", 0x9D},
{"YWYW", 0xDD},
{"YWZX", 0x2D},
{"YWZY", 0x6D},
{"YWZZ", 0xAD},
{"YWZW", 0xED},
{"YWWX", 0x3D},
{"YWWY", 0x7D},
{"YWWZ", 0xBD},
{"YWWW", 0xFD},
{"ZXXX", 0x2},
{"ZXXY", 0x42},
{"ZXXZ", 0x82},
{"ZXXW", 0xC2},
{"ZXYX", 0x12},
{"ZXYY", 0x52},
{"ZXYZ", 0x92},
{"ZXYW", 0xD2},
{"ZXZX", 0x22},
{"ZXZY", 0x62},
{"ZXZZ", 0xA2},
{"ZXZW", 0xE2},
{"ZXWX", 0x32},
{"ZXWY", 0x72},
{"ZXWZ", 0xB2},
{"ZXWW", 0xF2},
{"ZYXX", 0x6},
{"ZYXY", 0x46},
{"ZYXZ", 0x86},
{"ZYXW", 0xC6},
{"ZYYX", 0x16},
{"ZYYY", 0x56},
{"ZYYZ", 0x96},
{"ZYYW", 0xD6},
{"ZYZX", 0x26},
{"ZYZY", 0x66},
{"ZYZZ", 0xA6},
{"ZYZW", 0xE6},
{"ZYWX", 0x36},
{"ZYWY", 0x76},
{"ZYWZ", 0xB6},
{"ZYWW", 0xF6},
{"ZZXX", 0xA},
{"ZZXY", 0x4A},
{"ZZXZ", 0x8A},
{"ZZXW", 0xCA},
{"ZZYX", 0x1A},
{"ZZYY", 0x5A},
{"ZZYZ", 0x9A},
{"ZZYW", 0xDA},
{"ZZZX", 0x2A},
{"ZZZY", 0x6A},
{"ZZZZ", 0xAA},
{"ZZZW", 0xEA},
{"ZZWX", 0x3A},
{"ZZWY", 0x7A},
{"ZZWZ", 0xBA},
{"ZZWW", 0xFA},
{"ZWXX", 0xE},
{"ZWXY", 0x4E},
{"ZWXZ", 0x8E},
{"ZWXW", 0xCE},
{"ZWYX", 0x1E},
{"ZWYY", 0x5E},
{"ZWYZ", 0x9E},
{"ZWYW", 0xDE},
{"ZWZX", 0x2E},
{"ZWZY", 0x6E},
{"ZWZZ", 0xAE},
{"ZWZW", 0xEE},
{"ZWWX", 0x3E},
{"ZWWY", 0x7E},
{"ZWWZ", 0xBE},
{"ZWWW", 0xFE},
{"WXXX", 0x3},
{"WXXY", 0x43},
{"WXXZ", 0x83},
{"WXXW", 0xC3},
{"WXYX", 0x13},
{"WXYY", 0x53},
{"WXYZ", 0x93},
{"WXYW", 0xD3},
{"WXZX", 0x23},
{"WXZY", 0x63},
{"WXZZ", 0xA3},
{"WXZW", 0xE3},
{"WXWX", 0x33},
{"WXWY", 0x73},
{"WXWZ", 0xB3},
{"WXWW", 0xF3},
{"WYXX", 0x7},
{"WYXY", 0x47},
{"WYXZ", 0x87},
{"WYXW", 0xC7},
{"WYYX", 0x17},
{"WYYY", 0x57},
{"WYYZ", 0x97},
{"WYYW", 0xD7},
{"WYZX", 0x27},
{"WYZY", 0x67},
{"WYZZ", 0xA7},
{"WYZW", 0xE7},
{"WYWX", 0x37},
{"WYWY", 0x77},
{"WYWZ", 0xB7},
{"WYWW", 0xF7},
{"WZXX", 0xB},
{"WZXY", 0x4B},
{"WZXZ", 0x8B},
{"WZXW", 0xCB},
{"WZYX", 0x1B},
{"WZYY", 0x5B},
{"WZYZ", 0x9B},
{"WZYW", 0xDB},
{"WZZX", 0x2B},
{"WZZY", 0x6B},
{"WZZZ", 0xAB},
{"WZZW", 0xEB},
{"WZWX", 0x3B},
{"WZWY", 0x7B},
{"WZWZ", 0xBB},
{"WZWW", 0xFB},
{"WWXX", 0xF},
{"WWXY", 0x4F},
{"WWXZ", 0x8F},
{"WWXW", 0xCF},
{"WWYX", 0x1F},
{"WWYY", 0x5F},
{"WWYZ", 0x9F},
{"WWYW", 0xDF},
{"WWZX", 0x2F},
{"WWZY", 0x6F},
{"WWZZ", 0xAF},
{"WWZW", 0xEF},
{"WWWX", 0x3F},
{"WWWY", 0x7F},
{"WWWZ", 0xBF},
{"WWWW", 0xFF},
{"XX", 0x0},
{"XY", 0x2},
{"YX", 0x1},
{"YY", 0x3},
{0,0}
};
JSObject *
SIMDObject::initClass(JSContext *cx, Handle<GlobalObject *> global)
{
@ -652,9 +388,6 @@ SIMDObject::initClass(JSContext *cx, Handle<GlobalObject *> global)
if (!SIMD)
return nullptr;
if (!JS_DefineConstIntegers(cx, SIMD, SHUFFLE_MASKS))
return nullptr;
// float32x4
RootedObject float32x4Object(cx);
float32x4Object = CreateSimdClass<Float32x4Defn>(cx, global,

274
js/src/tests/ecma_6/TypedObject/simd/shufflemaskconstants.js
View File

@ -1,274 +0,0 @@
// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
var BUGNUMBER = 1050214;
var summary = "SIMD shuffle mask's constants";
function test() {
print(BUGNUMBER + ": " + summary);
assertEq(SIMD.XXXX, 0x0);
assertEq(SIMD.XXXY, 0x40);
assertEq(SIMD.XXXZ, 0x80);
assertEq(SIMD.XXXW, 0xC0);
assertEq(SIMD.XXYX, 0x10);
assertEq(SIMD.XXYY, 0x50);
assertEq(SIMD.XXYZ, 0x90);
assertEq(SIMD.XXYW, 0xD0);
assertEq(SIMD.XXZX, 0x20);
assertEq(SIMD.XXZY, 0x60);
assertEq(SIMD.XXZZ, 0xA0);
assertEq(SIMD.XXZW, 0xE0);
assertEq(SIMD.XXWX, 0x30);
assertEq(SIMD.XXWY, 0x70);
assertEq(SIMD.XXWZ, 0xB0);
assertEq(SIMD.XXWW, 0xF0);
assertEq(SIMD.XYXX, 0x4);
assertEq(SIMD.XYXY, 0x44);
assertEq(SIMD.XYXZ, 0x84);
assertEq(SIMD.XYXW, 0xC4);
assertEq(SIMD.XYYX, 0x14);
assertEq(SIMD.XYYY, 0x54);
assertEq(SIMD.XYYZ, 0x94);
assertEq(SIMD.XYYW, 0xD4);
assertEq(SIMD.XYZX, 0x24);
assertEq(SIMD.XYZY, 0x64);
assertEq(SIMD.XYZZ, 0xA4);
assertEq(SIMD.XYZW, 0xE4);
assertEq(SIMD.XYWX, 0x34);
assertEq(SIMD.XYWY, 0x74);
assertEq(SIMD.XYWZ, 0xB4);
assertEq(SIMD.XYWW, 0xF4);
assertEq(SIMD.XZXX, 0x8);
assertEq(SIMD.XZXY, 0x48);
assertEq(SIMD.XZXZ, 0x88);
assertEq(SIMD.XZXW, 0xC8);
assertEq(SIMD.XZYX, 0x18);
assertEq(SIMD.XZYY, 0x58);
assertEq(SIMD.XZYZ, 0x98);
assertEq(SIMD.XZYW, 0xD8);
assertEq(SIMD.XZZX, 0x28);
assertEq(SIMD.XZZY, 0x68);
assertEq(SIMD.XZZZ, 0xA8);
assertEq(SIMD.XZZW, 0xE8);
assertEq(SIMD.XZWX, 0x38);
assertEq(SIMD.XZWY, 0x78);
assertEq(SIMD.XZWZ, 0xB8);
assertEq(SIMD.XZWW, 0xF8);
assertEq(SIMD.XWXX, 0xC);
assertEq(SIMD.XWXY, 0x4C);
assertEq(SIMD.XWXZ, 0x8C);
assertEq(SIMD.XWXW, 0xCC);
assertEq(SIMD.XWYX, 0x1C);
assertEq(SIMD.XWYY, 0x5C);
assertEq(SIMD.XWYZ, 0x9C);
assertEq(SIMD.XWYW, 0xDC);
assertEq(SIMD.XWZX, 0x2C);
assertEq(SIMD.XWZY, 0x6C);
assertEq(SIMD.XWZZ, 0xAC);
assertEq(SIMD.XWZW, 0xEC);
assertEq(SIMD.XWWX, 0x3C);
assertEq(SIMD.XWWY, 0x7C);
assertEq(SIMD.XWWZ, 0xBC);
assertEq(SIMD.XWWW, 0xFC);
assertEq(SIMD.YXXX, 0x1);
assertEq(SIMD.YXXY, 0x41);
assertEq(SIMD.YXXZ, 0x81);
assertEq(SIMD.YXXW, 0xC1);
assertEq(SIMD.YXYX, 0x11);
assertEq(SIMD.YXYY, 0x51);
assertEq(SIMD.YXYZ, 0x91);
assertEq(SIMD.YXYW, 0xD1);
assertEq(SIMD.YXZX, 0x21);
assertEq(SIMD.YXZY, 0x61);
assertEq(SIMD.YXZZ, 0xA1);
assertEq(SIMD.YXZW, 0xE1);
assertEq(SIMD.YXWX, 0x31);
assertEq(SIMD.YXWY, 0x71);
assertEq(SIMD.YXWZ, 0xB1);
assertEq(SIMD.YXWW, 0xF1);
assertEq(SIMD.YYXX, 0x5);
assertEq(SIMD.YYXY, 0x45);
assertEq(SIMD.YYXZ, 0x85);
assertEq(SIMD.YYXW, 0xC5);
assertEq(SIMD.YYYX, 0x15);
assertEq(SIMD.YYYY, 0x55);
assertEq(SIMD.YYYZ, 0x95);
assertEq(SIMD.YYYW, 0xD5);
assertEq(SIMD.YYZX, 0x25);
assertEq(SIMD.YYZY, 0x65);
assertEq(SIMD.YYZZ, 0xA5);
assertEq(SIMD.YYZW, 0xE5);
assertEq(SIMD.YYWX, 0x35);
assertEq(SIMD.YYWY, 0x75);
assertEq(SIMD.YYWZ, 0xB5);
assertEq(SIMD.YYWW, 0xF5);
assertEq(SIMD.YZXX, 0x9);
assertEq(SIMD.YZXY, 0x49);
assertEq(SIMD.YZXZ, 0x89);
assertEq(SIMD.YZXW, 0xC9);
assertEq(SIMD.YZYX, 0x19);
assertEq(SIMD.YZYY, 0x59);
assertEq(SIMD.YZYZ, 0x99);
assertEq(SIMD.YZYW, 0xD9);
assertEq(SIMD.YZZX, 0x29);
assertEq(SIMD.YZZY, 0x69);
assertEq(SIMD.YZZZ, 0xA9);
assertEq(SIMD.YZZW, 0xE9);
assertEq(SIMD.YZWX, 0x39);
assertEq(SIMD.YZWY, 0x79);
assertEq(SIMD.YZWZ, 0xB9);
assertEq(SIMD.YZWW, 0xF9);
assertEq(SIMD.YWXX, 0xD);
assertEq(SIMD.YWXY, 0x4D);
assertEq(SIMD.YWXZ, 0x8D);
assertEq(SIMD.YWXW, 0xCD);
assertEq(SIMD.YWYX, 0x1D);
assertEq(SIMD.YWYY, 0x5D);
assertEq(SIMD.YWYZ, 0x9D);
assertEq(SIMD.YWYW, 0xDD);
assertEq(SIMD.YWZX, 0x2D);
assertEq(SIMD.YWZY, 0x6D);
assertEq(SIMD.YWZZ, 0xAD);
assertEq(SIMD.YWZW, 0xED);
assertEq(SIMD.YWWX, 0x3D);
assertEq(SIMD.YWWY, 0x7D);
assertEq(SIMD.YWWZ, 0xBD);
assertEq(SIMD.YWWW, 0xFD);
assertEq(SIMD.ZXXX, 0x2);
assertEq(SIMD.ZXXY, 0x42);
assertEq(SIMD.ZXXZ, 0x82);
assertEq(SIMD.ZXXW, 0xC2);
assertEq(SIMD.ZXYX, 0x12);
assertEq(SIMD.ZXYY, 0x52);
assertEq(SIMD.ZXYZ, 0x92);
assertEq(SIMD.ZXYW, 0xD2);
assertEq(SIMD.ZXZX, 0x22);
assertEq(SIMD.ZXZY, 0x62);
assertEq(SIMD.ZXZZ, 0xA2);
assertEq(SIMD.ZXZW, 0xE2);
assertEq(SIMD.ZXWX, 0x32);
assertEq(SIMD.ZXWY, 0x72);
assertEq(SIMD.ZXWZ, 0xB2);
assertEq(SIMD.ZXWW, 0xF2);
assertEq(SIMD.ZYXX, 0x6);
assertEq(SIMD.ZYXY, 0x46);
assertEq(SIMD.ZYXZ, 0x86);
assertEq(SIMD.ZYXW, 0xC6);
assertEq(SIMD.ZYYX, 0x16);
assertEq(SIMD.ZYYY, 0x56);
assertEq(SIMD.ZYYZ, 0x96);
assertEq(SIMD.ZYYW, 0xD6);
assertEq(SIMD.ZYZX, 0x26);
assertEq(SIMD.ZYZY, 0x66);
assertEq(SIMD.ZYZZ, 0xA6);
assertEq(SIMD.ZYZW, 0xE6);
assertEq(SIMD.ZYWX, 0x36);
assertEq(SIMD.ZYWY, 0x76);
assertEq(SIMD.ZYWZ, 0xB6);
assertEq(SIMD.ZYWW, 0xF6);
assertEq(SIMD.ZZXX, 0xA);
assertEq(SIMD.ZZXY, 0x4A);
assertEq(SIMD.ZZXZ, 0x8A);
assertEq(SIMD.ZZXW, 0xCA);
assertEq(SIMD.ZZYX, 0x1A);
assertEq(SIMD.ZZYY, 0x5A);
assertEq(SIMD.ZZYZ, 0x9A);
assertEq(SIMD.ZZYW, 0xDA);
assertEq(SIMD.ZZZX, 0x2A);
assertEq(SIMD.ZZZY, 0x6A);
assertEq(SIMD.ZZZZ, 0xAA);
assertEq(SIMD.ZZZW, 0xEA);
assertEq(SIMD.ZZWX, 0x3A);
assertEq(SIMD.ZZWY, 0x7A);
assertEq(SIMD.ZZWZ, 0xBA);
assertEq(SIMD.ZZWW, 0xFA);
assertEq(SIMD.ZWXX, 0xE);
assertEq(SIMD.ZWXY, 0x4E);
assertEq(SIMD.ZWXZ, 0x8E);
assertEq(SIMD.ZWXW, 0xCE);
assertEq(SIMD.ZWYX, 0x1E);
assertEq(SIMD.ZWYY, 0x5E);
assertEq(SIMD.ZWYZ, 0x9E);
assertEq(SIMD.ZWYW, 0xDE);
assertEq(SIMD.ZWZX, 0x2E);
assertEq(SIMD.ZWZY, 0x6E);
assertEq(SIMD.ZWZZ, 0xAE);
assertEq(SIMD.ZWZW, 0xEE);
assertEq(SIMD.ZWWX, 0x3E);
assertEq(SIMD.ZWWY, 0x7E);
assertEq(SIMD.ZWWZ, 0xBE);
assertEq(SIMD.ZWWW, 0xFE);
assertEq(SIMD.WXXX, 0x3);
assertEq(SIMD.WXXY, 0x43);
assertEq(SIMD.WXXZ, 0x83);
assertEq(SIMD.WXXW, 0xC3);
assertEq(SIMD.WXYX, 0x13);
assertEq(SIMD.WXYY, 0x53);
assertEq(SIMD.WXYZ, 0x93);
assertEq(SIMD.WXYW, 0xD3);
assertEq(SIMD.WXZX, 0x23);
assertEq(SIMD.WXZY, 0x63);
assertEq(SIMD.WXZZ, 0xA3);
assertEq(SIMD.WXZW, 0xE3);
assertEq(SIMD.WXWX, 0x33);
assertEq(SIMD.WXWY, 0x73);
assertEq(SIMD.WXWZ, 0xB3);
assertEq(SIMD.WXWW, 0xF3);
assertEq(SIMD.WYXX, 0x7);
assertEq(SIMD.WYXY, 0x47);
assertEq(SIMD.WYXZ, 0x87);
assertEq(SIMD.WYXW, 0xC7);
assertEq(SIMD.WYYX, 0x17);
assertEq(SIMD.WYYY, 0x57);
assertEq(SIMD.WYYZ, 0x97);
assertEq(SIMD.WYYW, 0xD7);
assertEq(SIMD.WYZX, 0x27);
assertEq(SIMD.WYZY, 0x67);
assertEq(SIMD.WYZZ, 0xA7);
assertEq(SIMD.WYZW, 0xE7);
assertEq(SIMD.WYWX, 0x37);
assertEq(SIMD.WYWY, 0x77);
assertEq(SIMD.WYWZ, 0xB7);
assertEq(SIMD.WYWW, 0xF7);
assertEq(SIMD.WZXX, 0xB);
assertEq(SIMD.WZXY, 0x4B);
assertEq(SIMD.WZXZ, 0x8B);
assertEq(SIMD.WZXW, 0xCB);
assertEq(SIMD.WZYX, 0x1B);
assertEq(SIMD.WZYY, 0x5B);
assertEq(SIMD.WZYZ, 0x9B);
assertEq(SIMD.WZYW, 0xDB);
assertEq(SIMD.WZZX, 0x2B);
assertEq(SIMD.WZZY, 0x6B);
assertEq(SIMD.WZZZ, 0xAB);
assertEq(SIMD.WZZW, 0xEB);
assertEq(SIMD.WZWX, 0x3B);
assertEq(SIMD.WZWY, 0x7B);
assertEq(SIMD.WZWZ, 0xBB);
assertEq(SIMD.WZWW, 0xFB);
assertEq(SIMD.WWXX, 0xF);
assertEq(SIMD.WWXY, 0x4F);
assertEq(SIMD.WWXZ, 0x8F);
assertEq(SIMD.WWXW, 0xCF);
assertEq(SIMD.WWYX, 0x1F);
assertEq(SIMD.WWYY, 0x5F);
assertEq(SIMD.WWYZ, 0x9F);
assertEq(SIMD.WWYW, 0xDF);
assertEq(SIMD.WWZX, 0x2F);
assertEq(SIMD.WWZY, 0x6F);
assertEq(SIMD.WWZZ, 0xAF);
assertEq(SIMD.WWZW, 0xEF);
assertEq(SIMD.WWWX, 0x3F);
assertEq(SIMD.WWWY, 0x7F);
assertEq(SIMD.WWWZ, 0xBF);
assertEq(SIMD.WWWW, 0xFF);
assertEq(SIMD.XX, 0x0);
assertEq(SIMD.XY, 0x2);
assertEq(SIMD.YX, 0x1);
assertEq(SIMD.YY, 0x3);
if (typeof reportCompare === "function")
reportCompare(true, true);
}
test();