diff options
| -rw-r--r-- | source/slang/slang-emit-c-like.cpp | 77 | ||||
| -rw-r--r-- | tests/wgsl/associativity.slang | 952 | ||||
| -rw-r--r-- | tests/wgsl/associativity.slang.expected.txt | 268 |
3 files changed, 1297 insertions, 0 deletions
diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp index 7ed4d2e4c..b63b9118e 100644 --- a/source/slang/slang-emit-c-like.cpp +++ b/source/slang/slang-emit-c-like.cpp @@ -733,6 +733,83 @@ bool CLikeSourceEmitter::maybeEmitParens(EmitOpInfo& outerPrec, const EmitOpInfo { needParens = true; } + // a ^ b * c => a ^ (b * c) + else if ( + prec.leftPrecedence == EPrecedence::kEPrecedence_Multiplicative_Left && + outerPrec.leftPrecedence == EPrecedence::kEPrecedence_BitXor_Right) + { + needParens = true; + } + // a * b ^ c => (a * b) ^ c + else if ( + prec.rightPrecedence == EPrecedence::kEPrecedence_Multiplicative_Right && + outerPrec.rightPrecedence == EPrecedence::kEPrecedence_BitXor_Left) + { + needParens = true; + } + // a | b * c => a | (b * c) + else if ( + prec.leftPrecedence == EPrecedence::kEPrecedence_Multiplicative_Left && + outerPrec.leftPrecedence == EPrecedence::kEPrecedence_BitOr_Right) + { + needParens = true; + } + // a * b | c => (a * b) | c + else if ( + prec.rightPrecedence == EPrecedence::kEPrecedence_Multiplicative_Right && + outerPrec.rightPrecedence == EPrecedence::kEPrecedence_BitOr_Left) + { + needParens = true; + } + // a & b * c => a & (b * c) + else if ( + prec.leftPrecedence == EPrecedence::kEPrecedence_Multiplicative_Left && + outerPrec.leftPrecedence == EPrecedence::kEPrecedence_BitAnd_Right) + { + needParens = true; + } + // a * b & c => (a * b) & c + else if ( + prec.rightPrecedence == EPrecedence::kEPrecedence_Multiplicative_Right && + outerPrec.rightPrecedence == EPrecedence::kEPrecedence_BitAnd_Left) + { + needParens = true; + } + // a << b * c => a << (b * c) + else if ( + prec.leftPrecedence == EPrecedence::kEPrecedence_Multiplicative_Left && + outerPrec.leftPrecedence == EPrecedence::kEPrecedence_Shift_Right) + { + needParens = true; + } + // a * b << c => (a * b) << c + else if ( + prec.rightPrecedence == EPrecedence::kEPrecedence_Multiplicative_Right && + outerPrec.rightPrecedence == EPrecedence::kEPrecedence_Shift_Left) + { + needParens = true; + } + // a != b == c => (a != b) == c + else if ( + prec.rightPrecedence == EPrecedence::kEPrecedence_Equality_Right && + outerPrec.rightPrecedence == EPrecedence::kEPrecedence_Equality_Left) + { + needParens = true; + } + // a == b < c => a == (b < c) + else if ( + prec.leftPrecedence == EPrecedence::kEPrecedence_Relational_Left && + outerPrec.leftPrecedence == EPrecedence::kEPrecedence_Equality_Right) + { + needParens = true; + } + // a < b == c => (a < b) == c + else if ( + prec.rightPrecedence == EPrecedence::kEPrecedence_Relational_Right && + outerPrec.rightPrecedence == EPrecedence::kEPrecedence_Equality_Left) + { + needParens = true; + } if (needParens) { diff --git a/tests/wgsl/associativity.slang b/tests/wgsl/associativity.slang new file mode 100644 index 000000000..3c9ede949 --- /dev/null +++ b/tests/wgsl/associativity.slang @@ -0,0 +1,952 @@ +//TEST(compute):COMPARE_COMPUTE:-shaderobj + +//TEST_INPUT:ubuffer(data=[3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8 7 3 8], stride=4):name=input +RWStructuredBuffer<uint> input; + +//TEST_INPUT:ubuffer(data=[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], stride=4):out,name=output +RWStructuredBuffer<uint> output; + +[numthreads(1,1,1)] +void computeMain() +{ + + uint na; // 3 + uint nb; // 7 + uint nc; // 8 + bool ba; // true + bool bb; // false + bool bc; // true + + // The following test cases are generated by this Python program: + // def pairs(a, b): + // for x in a: + // for y in b: + // yield (x, y) + // + // nn = ['^', '|', '&', '*', '/', '%', '+', '-', '<<', '>>']; + // xb = ['<', '>', '<=', '>=', '==', '!='] + // bb = ['&&', '||', '==', '!='] + // rl = ['<', '>', '<=', '>='] + // eq = ['==', '!='] + // lg = ['&&', '||'] + // + // iidx = 0 + // oidx = 0 + // + // for (l, r) in pairs(nn, nn): + // print("na = input[{}];".format(iidx + 0)) + // print("nb = input[{}];".format(iidx + 1)) + // print("nc = input[{}];".format(iidx + 2)) + // print("output[{}] = na {} nb {} nc;".format(oidx, l, r)) + // oidx += 1 + // iidx += 3 + // + // for (l, r) in pairs(nn, xb): + // print("na = input[{}];".format(iidx + 0)) + // print("nb = input[{}];".format(iidx + 1)) + // print("nc = input[{}];".format(iidx + 2)) + // print("output[{}] = uint(na {} nb {} nc);".format(oidx, l, r)) + // oidx += 1 + // print("output[{}] = uint(na {} nb {} nc);".format(oidx, r, l)) + // oidx += 1 + // iidx += 3 + // + // for (l, r) in pairs(bb, bb): + // print("ba = bool(input[{}] & 1);".format(iidx + 0)) + // print("bb = bool(input[{}] & 16);".format(iidx + 1)) + // print("bc = bool(input[{}] & 8);".format(iidx + 2)) + // print("output[{}] = uint(ba {} bb {} bc);".format(oidx, l, r)) + // oidx += 1 + // iidx += 3 + // + // for (l, r) in pairs(eq + lg, rl): + // print("na = input[{}];".format(iidx + 0)) + // print("nb = input[{}];".format(iidx + 1)) + // print("nc = input[{}];".format(iidx + 2)) + // print("ba = bool(input[{}] & 1);".format(iidx + 3)) + // print("bc = bool(input[{}] & 8);".format(iidx + 4)) + // print("output[{}] = uint(ba {} nb {} nc);".format(oidx, l, r)) + // oidx += 1 + // print("output[{}] = uint(na {} nb {} bc);".format(oidx, r, l)) + // oidx += 1 + // iidx += 5 + + na = input[0]; + nb = input[1]; + nc = input[2]; + output[0] = na ^ nb ^ nc; + na = input[3]; + nb = input[4]; + nc = input[5]; + output[1] = na ^ nb | nc; + na = input[6]; + nb = input[7]; + nc = input[8]; + output[2] = na ^ nb & nc; + na = input[9]; + nb = input[10]; + nc = input[11]; + output[3] = na ^ nb * nc; + na = input[12]; + nb = input[13]; + nc = input[14]; + output[4] = na ^ nb / nc; + na = input[15]; + nb = input[16]; + nc = input[17]; + output[5] = na ^ nb % nc; + na = input[18]; + nb = input[19]; + nc = input[20]; + output[6] = na ^ nb + nc; + na = input[21]; + nb = input[22]; + nc = input[23]; + output[7] = na ^ nb - nc; + na = input[24]; + nb = input[25]; + nc = input[26]; + output[8] = na ^ nb << nc; + na = input[27]; + nb = input[28]; + nc = input[29]; + output[9] = na ^ nb >> nc; + na = input[30]; + nb = input[31]; + nc = input[32]; + output[10] = na | nb ^ nc; + na = input[33]; + nb = input[34]; + nc = input[35]; + output[11] = na | nb | nc; + na = input[36]; + nb = input[37]; + nc = input[38]; + output[12] = na | nb & nc; + na = input[39]; + nb = input[40]; + nc = input[41]; + output[13] = na | nb * nc; + na = input[42]; + nb = input[43]; + nc = input[44]; + output[14] = na | nb / nc; + na = input[45]; + nb = input[46]; + nc = input[47]; + output[15] = na | nb % nc; + na = input[48]; + nb = input[49]; + nc = input[50]; + output[16] = na | nb + nc; + na = input[51]; + nb = input[52]; + nc = input[53]; + output[17] = na | nb - nc; + na = input[54]; + nb = input[55]; + nc = input[56]; + output[18] = na | nb << nc; + na = input[57]; + nb = input[58]; + nc = input[59]; + output[19] = na | nb >> nc; + na = input[60]; + nb = input[61]; + nc = input[62]; + output[20] = na & nb ^ nc; + na = input[63]; + nb = input[64]; + nc = input[65]; + output[21] = na & nb | nc; + na = input[66]; + nb = input[67]; + nc = input[68]; + output[22] = na & nb & nc; + na = input[69]; + nb = input[70]; + nc = input[71]; + output[23] = na & nb * nc; + na = input[72]; + nb = input[73]; + nc = input[74]; + output[24] = na & nb / nc; + na = input[75]; + nb = input[76]; + nc = input[77]; + output[25] = na & nb % nc; + na = input[78]; + nb = input[79]; + nc = input[80]; + output[26] = na & nb + nc; + na = input[81]; + nb = input[82]; + nc = input[83]; + output[27] = na & nb - nc; + na = input[84]; + nb = input[85]; + nc = input[86]; + output[28] = na & nb << nc; + na = input[87]; + nb = input[88]; + nc = input[89]; + output[29] = na & nb >> nc; + na = input[90]; + nb = input[91]; + nc = input[92]; + output[30] = na * nb ^ nc; + na = input[93]; + nb = input[94]; + nc = input[95]; + output[31] = na * nb | nc; + na = input[96]; + nb = input[97]; + nc = input[98]; + output[32] = na * nb & nc; + na = input[99]; + nb = input[100]; + nc = input[101]; + output[33] = na * nb * nc; + na = input[102]; + nb = input[103]; + nc = input[104]; + output[34] = na * nb / nc; + na = input[105]; + nb = input[106]; + nc = input[107]; + output[35] = na * nb % nc; + na = input[108]; + nb = input[109]; + nc = input[110]; + output[36] = na * nb + nc; + na = input[111]; + nb = input[112]; + nc = input[113]; + output[37] = na * nb - nc; + na = input[114]; + nb = input[115]; + nc = input[116]; + output[38] = na * nb << nc; + na = input[117]; + nb = input[118]; + nc = input[119]; + output[39] = na * nb >> nc; + na = input[120]; + nb = input[121]; + nc = input[122]; + output[40] = na / nb ^ nc; + na = input[123]; + nb = input[124]; + nc = input[125]; + output[41] = na / nb | nc; + na = input[126]; + nb = input[127]; + nc = input[128]; + output[42] = na / nb & nc; + na = input[129]; + nb = input[130]; + nc = input[131]; + output[43] = na / nb * nc; + na = input[132]; + nb = input[133]; + nc = input[134]; + output[44] = na / nb / nc; + na = input[135]; + nb = input[136]; + nc = input[137]; + output[45] = na / nb % nc; + na = input[138]; + nb = input[139]; + nc = input[140]; + output[46] = na / nb + nc; + na = input[141]; + nb = input[142]; + nc = input[143]; + output[47] = na / nb - nc; + na = input[144]; + nb = input[145]; + nc = input[146]; + output[48] = na / nb << nc; + na = input[147]; + nb = input[148]; + nc = input[149]; + output[49] = na / nb >> nc; + na = input[150]; + nb = input[151]; + nc = input[152]; + output[50] = na % nb ^ nc; + na = input[153]; + nb = input[154]; + nc = input[155]; + output[51] = na % nb | nc; + na = input[156]; + nb = input[157]; + nc = input[158]; + output[52] = na % nb & nc; + na = input[159]; + nb = input[160]; + nc = input[161]; + output[53] = na % nb * nc; + na = input[162]; + nb = input[163]; + nc = input[164]; + output[54] = na % nb / nc; + na = input[165]; + nb = input[166]; + nc = input[167]; + output[55] = na % nb % nc; + na = input[168]; + nb = input[169]; + nc = input[170]; + output[56] = na % nb + nc; + na = input[171]; + nb = input[172]; + nc = input[173]; + output[57] = na % nb - nc; + na = input[174]; + nb = input[175]; + nc = input[176]; + output[58] = na % nb << nc; + na = input[177]; + nb = input[178]; + nc = input[179]; + output[59] = na % nb >> nc; + na = input[180]; + nb = input[181]; + nc = input[182]; + output[60] = na + nb ^ nc; + na = input[183]; + nb = input[184]; + nc = input[185]; + output[61] = na + nb | nc; + na = input[186]; + nb = input[187]; + nc = input[188]; + output[62] = na + nb & nc; + na = input[189]; + nb = input[190]; + nc = input[191]; + output[63] = na + nb * nc; + na = input[192]; + nb = input[193]; + nc = input[194]; + output[64] = na + nb / nc; + na = input[195]; + nb = input[196]; + nc = input[197]; + output[65] = na + nb % nc; + na = input[198]; + nb = input[199]; + nc = input[200]; + output[66] = na + nb + nc; + na = input[201]; + nb = input[202]; + nc = input[203]; + output[67] = na + nb - nc; + na = input[204]; + nb = input[205]; + nc = input[206]; + output[68] = na + nb << nc; + na = input[207]; + nb = input[208]; + nc = input[209]; + output[69] = na + nb >> nc; + na = input[210]; + nb = input[211]; + nc = input[212]; + output[70] = na - nb ^ nc; + na = input[213]; + nb = input[214]; + nc = input[215]; + output[71] = na - nb | nc; + na = input[216]; + nb = input[217]; + nc = input[218]; + output[72] = na - nb & nc; + na = input[219]; + nb = input[220]; + nc = input[221]; + output[73] = na - nb * nc; + na = input[222]; + nb = input[223]; + nc = input[224]; + output[74] = na - nb / nc; + na = input[225]; + nb = input[226]; + nc = input[227]; + output[75] = na - nb % nc; + na = input[228]; + nb = input[229]; + nc = input[230]; + output[76] = na - nb + nc; + na = input[231]; + nb = input[232]; + nc = input[233]; + output[77] = na - nb - nc; + na = input[234]; + nb = input[235]; + nc = input[236]; + output[78] = na - nb << nc; + na = input[237]; + nb = input[238]; + nc = input[239]; + output[79] = na - nb >> nc; + na = input[240]; + nb = input[241]; + nc = input[242]; + output[80] = na << nb ^ nc; + na = input[243]; + nb = input[244]; + nc = input[245]; + output[81] = na << nb | nc; + na = input[246]; + nb = input[247]; + nc = input[248]; + output[82] = na << nb & nc; + na = input[249]; + nb = input[250]; + nc = input[251]; + output[83] = na << nb * nc; + na = input[252]; + nb = input[253]; + nc = input[254]; + output[84] = na << nb / nc; + na = input[255]; + nb = input[256]; + nc = input[257]; + output[85] = na << nb % nc; + na = input[258]; + nb = input[259]; + nc = input[260]; + output[86] = na << nb + nc; + na = input[261]; + nb = input[262]; + nc = input[263]; + output[87] = na << nb - nc; + na = input[264]; + nb = input[265]; + nc = input[266]; + output[88] = na << nb << nc; + na = input[267]; + nb = input[268]; + nc = input[269]; + output[89] = na << nb >> nc; + na = input[270]; + nb = input[271]; + nc = input[272]; + output[90] = na >> nb ^ nc; + na = input[273]; + nb = input[274]; + nc = input[275]; + output[91] = na >> nb | nc; + na = input[276]; + nb = input[277]; + nc = input[278]; + output[92] = na >> nb & nc; + na = input[279]; + nb = input[280]; + nc = input[281]; + output[93] = na >> nb * nc; + na = input[282]; + nb = input[283]; + nc = input[284]; + output[94] = na >> nb / nc; + na = input[285]; + nb = input[286]; + nc = input[287]; + output[95] = na >> nb % nc; + na = input[288]; + nb = input[289]; + nc = input[290]; + output[96] = na >> nb + nc; + na = input[291]; + nb = input[292]; + nc = input[293]; + output[97] = na >> nb - nc; + na = input[294]; + nb = input[295]; + nc = input[296]; + output[98] = na >> nb << nc; + na = input[297]; + nb = input[298]; + nc = input[299]; + output[99] = na >> nb >> nc; + na = input[300]; + nb = input[301]; + nc = input[302]; + output[100] = uint(na ^ nb < nc); + output[101] = uint(na < nb ^ nc); + na = input[303]; + nb = input[304]; + nc = input[305]; + output[102] = uint(na ^ nb > nc); + output[103] = uint(na > nb ^ nc); + na = input[306]; + nb = input[307]; + nc = input[308]; + output[104] = uint(na ^ nb <= nc); + output[105] = uint(na <= nb ^ nc); + na = input[309]; + nb = input[310]; + nc = input[311]; + output[106] = uint(na ^ nb >= nc); + output[107] = uint(na >= nb ^ nc); + na = input[312]; + nb = input[313]; + nc = input[314]; + output[108] = uint(na ^ nb == nc); + output[109] = uint(na == nb ^ nc); + na = input[315]; + nb = input[316]; + nc = input[317]; + output[110] = uint(na ^ nb != nc); + output[111] = uint(na != nb ^ nc); + na = input[318]; + nb = input[319]; + nc = input[320]; + output[112] = uint(na | nb < nc); + output[113] = uint(na < nb | nc); + na = input[321]; + nb = input[322]; + nc = input[323]; + output[114] = uint(na | nb > nc); + output[115] = uint(na > nb | nc); + na = input[324]; + nb = input[325]; + nc = input[326]; + output[116] = uint(na | nb <= nc); + output[117] = uint(na <= nb | nc); + na = input[327]; + nb = input[328]; + nc = input[329]; + output[118] = uint(na | nb >= nc); + output[119] = uint(na >= nb | nc); + na = input[330]; + nb = input[331]; + nc = input[332]; + output[120] = uint(na | nb == nc); + output[121] = uint(na == nb | nc); + na = input[333]; + nb = input[334]; + nc = input[335]; + output[122] = uint(na | nb != nc); + output[123] = uint(na != nb | nc); + na = input[336]; + nb = input[337]; + nc = input[338]; + output[124] = uint(na & nb < nc); + output[125] = uint(na < nb & nc); + na = input[339]; + nb = input[340]; + nc = input[341]; + output[126] = uint(na & nb > nc); + output[127] = uint(na > nb & nc); + na = input[342]; + nb = input[343]; + nc = input[344]; + output[128] = uint(na & nb <= nc); + output[129] = uint(na <= nb & nc); + na = input[345]; + nb = input[346]; + nc = input[347]; + output[130] = uint(na & nb >= nc); + output[131] = uint(na >= nb & nc); + na = input[348]; + nb = input[349]; + nc = input[350]; + output[132] = uint(na & nb == nc); + output[133] = uint(na == nb & nc); + na = input[351]; + nb = input[352]; + nc = input[353]; + output[134] = uint(na & nb != nc); + output[135] = uint(na != nb & nc); + na = input[354]; + nb = input[355]; + nc = input[356]; + output[136] = uint(na * nb < nc); + output[137] = uint(na < nb * nc); + na = input[357]; + nb = input[358]; + nc = input[359]; + output[138] = uint(na * nb > nc); + output[139] = uint(na > nb * nc); + na = input[360]; + nb = input[361]; + nc = input[362]; + output[140] = uint(na * nb <= nc); + output[141] = uint(na <= nb * nc); + na = input[363]; + nb = input[364]; + nc = input[365]; + output[142] = uint(na * nb >= nc); + output[143] = uint(na >= nb * nc); + na = input[366]; + nb = input[367]; + nc = input[368]; + output[144] = uint(na * nb == nc); + output[145] = uint(na == nb * nc); + na = input[369]; + nb = input[370]; + nc = input[371]; + output[146] = uint(na * nb != nc); + output[147] = uint(na != nb * nc); + na = input[372]; + nb = input[373]; + nc = input[374]; + output[148] = uint(na / nb < nc); + output[149] = uint(na < nb / nc); + na = input[375]; + nb = input[376]; + nc = input[377]; + output[150] = uint(na / nb > nc); + output[151] = uint(na > nb / nc); + na = input[378]; + nb = input[379]; + nc = input[380]; + output[152] = uint(na / nb <= nc); + output[153] = uint(na <= nb / nc); + na = input[381]; + nb = input[382]; + nc = input[383]; + output[154] = uint(na / nb >= nc); + output[155] = uint(na >= nb / nc); + na = input[384]; + nb = input[385]; + nc = input[386]; + output[156] = uint(na / nb == nc); + output[157] = uint(na == nb / nc); + na = input[387]; + nb = input[388]; + nc = input[389]; + output[158] = uint(na / nb != nc); + output[159] = uint(na != nb / nc); + na = input[390]; + nb = input[391]; + nc = input[392]; + output[160] = uint(na % nb < nc); + output[161] = uint(na < nb % nc); + na = input[393]; + nb = input[394]; + nc = input[395]; + output[162] = uint(na % nb > nc); + output[163] = uint(na > nb % nc); + na = input[396]; + nb = input[397]; + nc = input[398]; + output[164] = uint(na % nb <= nc); + output[165] = uint(na <= nb % nc); + na = input[399]; + nb = input[400]; + nc = input[401]; + output[166] = uint(na % nb >= nc); + output[167] = uint(na >= nb % nc); + na = input[402]; + nb = input[403]; + nc = input[404]; + output[168] = uint(na % nb == nc); + output[169] = uint(na == nb % nc); + na = input[405]; + nb = input[406]; + nc = input[407]; + output[170] = uint(na % nb != nc); + output[171] = uint(na != nb % nc); + na = input[408]; + nb = input[409]; + nc = input[410]; + output[172] = uint(na + nb < nc); + output[173] = uint(na < nb + nc); + na = input[411]; + nb = input[412]; + nc = input[413]; + output[174] = uint(na + nb > nc); + output[175] = uint(na > nb + nc); + na = input[414]; + nb = input[415]; + nc = input[416]; + output[176] = uint(na + nb <= nc); + output[177] = uint(na <= nb + nc); + na = input[417]; + nb = input[418]; + nc = input[419]; + output[178] = uint(na + nb >= nc); + output[179] = uint(na >= nb + nc); + na = input[420]; + nb = input[421]; + nc = input[422]; + output[180] = uint(na + nb == nc); + output[181] = uint(na == nb + nc); + na = input[423]; + nb = input[424]; + nc = input[425]; + output[182] = uint(na + nb != nc); + output[183] = uint(na != nb + nc); + na = input[426]; + nb = input[427]; + nc = input[428]; + output[184] = uint(na - nb < nc); + output[185] = uint(na < nb - nc); + na = input[429]; + nb = input[430]; + nc = input[431]; + output[186] = uint(na - nb > nc); + output[187] = uint(na > nb - nc); + na = input[432]; + nb = input[433]; + nc = input[434]; + output[188] = uint(na - nb <= nc); + output[189] = uint(na <= nb - nc); + na = input[435]; + nb = input[436]; + nc = input[437]; + output[190] = uint(na - nb >= nc); + output[191] = uint(na >= nb - nc); + na = input[438]; + nb = input[439]; + nc = input[440]; + output[192] = uint(na - nb == nc); + output[193] = uint(na == nb - nc); + na = input[441]; + nb = input[442]; + nc = input[443]; + output[194] = uint(na - nb != nc); + output[195] = uint(na != nb - nc); + na = input[444]; + nb = input[445]; + nc = input[446]; + output[196] = uint(na << nb < nc); + output[197] = uint(na < nb << nc); + na = input[447]; + nb = input[448]; + nc = input[449]; + output[198] = uint(na << nb > nc); + output[199] = uint(na > nb << nc); + na = input[450]; + nb = input[451]; + nc = input[452]; + output[200] = uint(na << nb <= nc); + output[201] = uint(na <= nb << nc); + na = input[453]; + nb = input[454]; + nc = input[455]; + output[202] = uint(na << nb >= nc); + output[203] = uint(na >= nb << nc); + na = input[456]; + nb = input[457]; + nc = input[458]; + output[204] = uint(na << nb == nc); + output[205] = uint(na == nb << nc); + na = input[459]; + nb = input[460]; + nc = input[461]; + output[206] = uint(na << nb != nc); + output[207] = uint(na != nb << nc); + na = input[462]; + nb = input[463]; + nc = input[464]; + output[208] = uint(na >> nb < nc); + // error 39999: expected a generic when using '<...>' (found: 'uint') + // output[209] = uint(na < nb >> nc); + na = input[465]; + nb = input[466]; + nc = input[467]; + output[210] = uint(na >> nb > nc); + output[211] = uint(na > nb >> nc); + na = input[468]; + nb = input[469]; + nc = input[470]; + output[212] = uint(na >> nb <= nc); + output[213] = uint(na <= nb >> nc); + na = input[471]; + nb = input[472]; + nc = input[473]; + output[214] = uint(na >> nb >= nc); + output[215] = uint(na >= nb >> nc); + na = input[474]; + nb = input[475]; + nc = input[476]; + output[216] = uint(na >> nb == nc); + output[217] = uint(na == nb >> nc); + na = input[477]; + nb = input[478]; + nc = input[479]; + output[218] = uint(na >> nb != nc); + output[219] = uint(na != nb >> nc); + ba = bool(input[480] & 1); + bb = bool(input[481] & 16); + bc = bool(input[482] & 8); + output[220] = uint(ba && bb && bc); + ba = bool(input[483] & 1); + bb = bool(input[484] & 16); + bc = bool(input[485] & 8); + output[221] = uint(ba && bb || bc); + ba = bool(input[486] & 1); + bb = bool(input[487] & 16); + bc = bool(input[488] & 8); + output[222] = uint(ba && bb == bc); + ba = bool(input[489] & 1); + bb = bool(input[490] & 16); + bc = bool(input[491] & 8); + output[223] = uint(ba && bb != bc); + ba = bool(input[492] & 1); + bb = bool(input[493] & 16); + bc = bool(input[494] & 8); + output[224] = uint(ba || bb && bc); + ba = bool(input[495] & 1); + bb = bool(input[496] & 16); + bc = bool(input[497] & 8); + output[225] = uint(ba || bb || bc); + ba = bool(input[498] & 1); + bb = bool(input[499] & 16); + bc = bool(input[500] & 8); + output[226] = uint(ba || bb == bc); + ba = bool(input[501] & 1); + bb = bool(input[502] & 16); + bc = bool(input[503] & 8); + output[227] = uint(ba || bb != bc); + ba = bool(input[504] & 1); + bb = bool(input[505] & 16); + bc = bool(input[506] & 8); + output[228] = uint(ba == bb && bc); + ba = bool(input[507] & 1); + bb = bool(input[508] & 16); + bc = bool(input[509] & 8); + output[229] = uint(ba == bb || bc); + ba = bool(input[510] & 1); + bb = bool(input[511] & 16); + bc = bool(input[512] & 8); + output[230] = uint(ba == bb == bc); + ba = bool(input[513] & 1); + bb = bool(input[514] & 16); + bc = bool(input[515] & 8); + output[231] = uint(ba == bb != bc); + ba = bool(input[516] & 1); + bb = bool(input[517] & 16); + bc = bool(input[518] & 8); + output[232] = uint(ba != bb && bc); + ba = bool(input[519] & 1); + bb = bool(input[520] & 16); + bc = bool(input[521] & 8); + output[233] = uint(ba != bb || bc); + ba = bool(input[522] & 1); + bb = bool(input[523] & 16); + bc = bool(input[524] & 8); + output[234] = uint(ba != bb == bc); + ba = bool(input[525] & 1); + bb = bool(input[526] & 16); + bc = bool(input[527] & 8); + output[235] = uint(ba != bb != bc); + na = input[528]; + nb = input[529]; + nc = input[530]; + ba = bool(input[531] & 1); + bc = bool(input[532] & 8); + output[236] = uint(ba == nb < nc); + output[237] = uint(na < nb == bc); + na = input[533]; + nb = input[534]; + nc = input[535]; + ba = bool(input[536] & 1); + bc = bool(input[537] & 8); + output[238] = uint(ba == nb > nc); + output[239] = uint(na > nb == bc); + na = input[538]; + nb = input[539]; + nc = input[540]; + ba = bool(input[541] & 1); + bc = bool(input[542] & 8); + output[240] = uint(ba == nb <= nc); + output[241] = uint(na <= nb == bc); + na = input[543]; + nb = input[544]; + nc = input[545]; + ba = bool(input[546] & 1); + bc = bool(input[547] & 8); + output[242] = uint(ba == nb >= nc); + output[243] = uint(na >= nb == bc); + na = input[548]; + nb = input[549]; + nc = input[550]; + ba = bool(input[551] & 1); + bc = bool(input[552] & 8); + output[244] = uint(ba != nb < nc); + output[245] = uint(na < nb != bc); + na = input[553]; + nb = input[554]; + nc = input[555]; + ba = bool(input[556] & 1); + bc = bool(input[557] & 8); + output[246] = uint(ba != nb > nc); + output[247] = uint(na > nb != bc); + na = input[558]; + nb = input[559]; + nc = input[560]; + ba = bool(input[561] & 1); + bc = bool(input[562] & 8); + output[248] = uint(ba != nb <= nc); + output[249] = uint(na <= nb != bc); + na = input[563]; + nb = input[564]; + nc = input[565]; + ba = bool(input[566] & 1); + bc = bool(input[567] & 8); + output[250] = uint(ba != nb >= nc); + output[251] = uint(na >= nb != bc); + na = input[568]; + nb = input[569]; + nc = input[570]; + ba = bool(input[571] & 1); + bc = bool(input[572] & 8); + output[252] = uint(ba && nb < nc); + output[253] = uint(na < nb && bc); + na = input[573]; + nb = input[574]; + nc = input[575]; + ba = bool(input[576] & 1); + bc = bool(input[577] & 8); + output[254] = uint(ba && nb > nc); + output[255] = uint(na > nb && bc); + na = input[578]; + nb = input[579]; + nc = input[580]; + ba = bool(input[581] & 1); + bc = bool(input[582] & 8); + output[256] = uint(ba && nb <= nc); + output[257] = uint(na <= nb && bc); + na = input[583]; + nb = input[584]; + nc = input[585]; + ba = bool(input[586] & 1); + bc = bool(input[587] & 8); + output[258] = uint(ba && nb >= nc); + output[259] = uint(na >= nb && bc); + na = input[588]; + nb = input[589]; + nc = input[590]; + ba = bool(input[591] & 1); + bc = bool(input[592] & 8); + output[260] = uint(ba || nb < nc); + output[261] = uint(na < nb || bc); + na = input[593]; + nb = input[594]; + nc = input[595]; + ba = bool(input[596] & 1); + bc = bool(input[597] & 8); + output[262] = uint(ba || nb > nc); + output[263] = uint(na > nb || bc); + na = input[598]; + nb = input[599]; + nc = input[600]; + ba = bool(input[601] & 1); + bc = bool(input[602] & 8); + output[264] = uint(ba || nb <= nc); + output[265] = uint(na <= nb || bc); + na = input[603]; + nb = input[604]; + nc = input[605]; + ba = bool(input[606] & 1); + bc = bool(input[607] & 8); + output[266] = uint(ba || nb >= nc); + output[267] = uint(na >= nb || bc); + +} diff --git a/tests/wgsl/associativity.slang.expected.txt b/tests/wgsl/associativity.slang.expected.txt new file mode 100644 index 000000000..aa7be0835 --- /dev/null +++ b/tests/wgsl/associativity.slang.expected.txt @@ -0,0 +1,268 @@ +C +F +3 +3B +2 +2 +C +2 +403 +3 +F +F +3 +3B +3 +3 +F +3 +403 +3 +7 +7 +0 +0 +1 +1 +3 +1 +0 +0 +1F +1F +0 +A8 +3 +3 +1F +11 +C00 +0 +7 +7 +0 +0 +0 +0 +7 +FFFFFFF9 +0 +0 +4 +7 +3 +15 +0 +3 +A +FFFFFFFC +180 +0 +C +F +3 +3B +4 +4 +12 +4 +580 +0 +FFFFFFFC +FFFFFFFF +3 +FFFFFFCB +2 +2 +2 +FFFFFFF4 +FFFFFD80 +1FFFFFF +307 +307 +0 +3000000 +6 +6 +18000 +6 +18000 +6 +7 +7 +0 +0 +1 +1 +0 +1 +0 +0 +3 +6 +2 +7 +3 +6 +2 +7 +3 +7 +2 +6 +3 +7 +3 +7 +3 +7 +3 +7 +3 +7 +3 +7 +0 +1 +1 +0 +0 +1 +1 +0 +0 +0 +1 +1 +0 +1 +1 +0 +0 +1 +1 +0 +0 +0 +1 +1 +1 +0 +0 +1 +1 +0 +0 +1 +0 +0 +1 +1 +1 +0 +0 +1 +1 +0 +0 +1 +0 +0 +1 +1 +0 +1 +1 +0 +0 +1 +1 +0 +0 +0 +1 +1 +0 +0 +1 +1 +0 +0 +1 +1 +0 +0 +1 +1 +0 +1 +1 +0 +0 +1 +1 +0 +0 +0 +1 +1 +1 +0 +0 +1 +1 +0 +0 +1 +0 +0 +1 +1 +0 +0 +1 +0 +1 +1 +1 +1 +0 +0 +1 +0 +0 +1 +0 +1 +0 +1 +0 +0 +1 +1 +1 +0 +0 +0 +1 +1 +1 +0 +1 +1 +0 +0 +1 +0 +1 +0 +0 +0 +1 +1 +1 +1 +0 +0 +1 +1 |