Visual C++ Optimizer oplossingen voor Visual Studio 2015 Update 3

Oplossing

Problemen die zijn opgelost in deze hotfix

Deze hotfix bevat oplossing voor de volgende problemen:

• Herstelt een bug in de optimizer als een lus variant voorwaardelijke winkel buiten een lus hoisting: #include <cstdlib> #include <cassert> struct Foo { int a; int b; }; int main() { Foo foo; foo.b = rand(); int a = rand(); int b = foo.b; for (int i = 0; i < 10; ++i) { int inner_b = b; int inner_a = a; if (inner_b < 0) // This gets incorrect hoisted outside the loop. // A workaround is /d2SSAOptimizer- { inner_a = 0; inner_b = 0; } if (inner_b >= 0) assert(inner_a == a); a += b; } return 0; }

   

• Oplossing voor een integer deling bug in de optimizer: #include <stdio.h> volatile int z = 0; int main() { unsigned a, b; __int64 c; a = z; c = a; c = (c == 0) ? 1LL : c; b = (unsigned)((__int64)a * 100 / c); // Division was made unconditional // incorrectly creating a divide by zero. // A workaround is /d2SSAOptimizer- printf("%u\n", b); return 0; }

   

• Oplossing voor een integer deling bug in de optimizer: int checkchecksum(int suly, int ell, int utkodert) { int x; ell -= utkodert; ell %= 103; if (suly - 1) utkodert /= (suly - 1); // Division was made unconditional, // incorrectly creating a potential divide by zero // A workaround is /d2SSAOptimizer- return utkodert; }

   

• Oplossing voor een integer deling bug in de optimizer: typedef int unsigned uint; volatile uint out_index = 0; bool data[1] = {true}; bool __declspec(noinline) BugSSA(uint index) { uint group = index / 3; if (group == 0) // The division result being compared to zero is replaced // with a range check. We then incorrectly move the division { // to the next use of "group", without accounting for the fact // that "index" has changed. A workaround is /d2SSAOptimizer- return false; } index -= 3; group--; bool ret = data[group]; // crash here out_index = index; out_index = index; return ret; } int main() { volatile uint i = 3; return BugSSA(i); }

   

• Correctie voor een crash in de optimizer voor afdeling van MIN_INT door -1: int test_div(bool flag, int dummy) { int result = std::numeric_limits<int>::min(); int other; if (flag) other = -1; else other = dummy - 1 - dummy; result /= other; // We would push the division up into both arms of the // if-then-else. One of those divisions would cause the // optimizer to evaluate MIN_INT/-1.This is a crash, similar // to dividing by zero. A workaround is /d2SSAOptimizer- return result; }

   

• Herstelt een stackoverloop in optimaliseren: #include <stdio.h> // This example produced a stack overflow in the optimizer, which was // caused by mutually-recursive analysis functions not properly tracking // the number of times they were invocated. // A workaround is /d2SSAOptimizer- typedef unsigned char byte; typedef unsigned long long int uint64; int main() { const uint64 *sieveData = new uint64[1024]; uint64 bitIndexShift = 0; uint64 curSieveChunk = 0xfafd7bbef7ffffffULL & ~uint64(3); const unsigned int *NumbersCoprimeToModulo = new unsigned int[16]; const unsigned int *PossiblePrimesForModuloPtr = NumbersCoprimeToModulo; while (!curSieveChunk) { curSieveChunk = *(sieveData++); const uint64 NewValues = (16 << 8) | (32 << 24); bitIndexShift = (NewValues >> (bitIndexShift + 8)) & 255; PossiblePrimesForModuloPtr = NumbersCoprimeToModulo + bitIndexShift; } if (PossiblePrimesForModuloPtr - NumbersCoprimeToModulo != 0) { printf("fail"); return 1; } printf("pass"); return 0; }

   

• Correctie voor onjuiste code genereren wanneer verwijderen redundante zwevende punt omzettingen waarbij een parameter int32 naar f64 converteert: #include <string> __declspec(noinline) void test(int Val) { double Val2 = Val; std::string Str; printf("%lld\n", __int64(Val2)); // We incorrectly try to read 64 bits of // floating point from the parameter area, // instead of reading 32 bits of integer // and converting it. A workaround is // to throw /d2SSAOptimizer- } int main() { test(6); test(7); return 0; }

   

• Verhelpt een crash in de optimizer als splitsen flow diagram knooppunten in een standaard-instructie van een schakelblok voor meer details, Zie https://bugs.chromium.org/p/chromium/issues/detail?id=627216#c15.

• Herstelt een bug in het optimaliseren van de lus waar we verkeerde sterkte vermindering van de niet-ondertekende secundaire inductie variabelen die veelvouden van de variabele primaire inductie zijn uitvoeren: #include <assert.h> #include <malloc.h> #include <stdio.h> typedef unsigned int uint; typedef unsigned char byte; /* There is a corner case in the compiler's loop optimizer. The corner case arose if an induction variable (IV) is a multiple of the loop index, and there's a comparison of the IV to an integer that is less than this multiplication factor. A workaround is to use #pragma optimize("", off) / #pragma optimize("", on) around the affected function. */ int main(int argc, char *argv[]) { const uint w = 256; const uint h = 64; const uint w_new = w >> 1; const uint h_new = h >> 1; const byte *const src = (byte *)malloc(w * h); byte *it_out = (byte *)malloc(w_new * h_new); int fail = 0; for (uint y_new = 0; y_new < h_new; ++y_new) { for (uint x_new = 0; x_new < w_new; ++x_new, ++it_out) { uint x = x_new * 2; uint y = y_new * 2; if (x < 1 || y < 1) { *it_out = 0; continue; } if (x != 0) { } else { fail = 1; } *it_out = 4 * src[y * w + x]; } } if (fail) { printf("fail\n"); return (1); } printf("pass\n"); return (0); }

   

• Biedt een oplossing voor C4883 ": functie grootte optimalisaties onderdrukt". Wanneer de optimizer functies die enorm zijn, zij kan worden uitgebreid terug optimalisaties die worden uitgevoerd. Deze geven een C4883 waarschuwing wanneer dit gebeurt, als u de waarschuwing via /we4883 hebt ingeschakeld. Als u overschrijven deze beschikking optimalisaties onderdrukken wilt, genereren de /d2OptimizeHugeFunctions-switch.

• Oplossingen voor een crash compiler in c2! PpCanPropagateForward als u een optimalisatie op x64 uitvoert.

• Correcties voor lus optimizer fouten waarbij onjuiste inductie variabele sterkte vermindering.

• Oplossingen voor onjuiste volgorde wijzigen van expressies waarbij leest & schrijft naar geheugen vanwege onjuiste alias controleren.

• Oplossingen voor een register allocator bug waarbij een compiler gegenereerd tijdelijke bestaande over meerdere regio's de verwerking van uitzonderingen.

Status

Microsoft heeft bevestigd dat dit probleem kan optreden in de Microsoft-producten die worden vermeld in de sectie 'Van toepassing op'.