Bugs Fixed in Visual Studio 2013 Update 2

Bugs Fixed in Visual Studio 2013 Update 2

Rate This
  • Comments 10

Visual Studio 2013 Update 2 includes a number of fixes filed through Connect:

  • Free functions can be called using curly braces instead of parentheses. (link)
  • When attempting to expand a recursive template, the compiler uses large amounts of memory and then crashes.
  • Internal compiler error. (link)
  • C99: Use of _Complex with an incorrect storage class can cause internal compiler errors. (link)
  • C99: Functions returning bool can return something other than true or false. (link)
  • C99: A cast operator has wrong precedence when dereferencing a compound literal. (link)
  • Uniform initialization combined with ternary operators can cause internal compiler errors.
  • When initializer lists are used, the destructors of temporary objects can be called twice. (link)
  • The "this" pointer can have a wrong value in a virtual function call with a qualified name. (link, link)
  • The compiler rejects correct covariant returns. (link)
  • Variadic templates can cause internal compiler errors. (link)
  • Initializer lists combined with unique pointers can cause heap corruption. (link)
  • Variadic templates combined with "using" type definitions can cause internal compiler errors. (link)
  • Variadic templates can cause internal compiler errors. (link)
  • Types expanded by variadic templates can't be used in template<> brackets. (link)
  • Internal compiler error.
  • Variadic templates combined with decltype can cause internal compiler errors.
  • Variadic templates can cause internal compiler errors. (link)
  • The compiler rejects correct code involving variadic templates. (link)
  • f(const T&) is not considered more specialized than f(const Args&…)
  • Template specialization on variadic function arguments can cause internal compiler errors. (link)
  • Variadic templates can cause internal compiler errors.
  • The sizeof… operator for variadic templates can cause internal compiler errors. (link)
  • The compiler incorrectly rejects some orderings of partial specializations.
  • System::Runtime::Serialization::XsdDataContractExporter::CanExport() behaves incorrectly. (link)
  • The compiler can emit an incorrect error about type conversion in a function application.
  • Complex templates combined with std::remove_reference can cause internal compiler errors. (link)
  • The stringizing operator behaves inconsistently when question marks are used in the operand. (link)
  • Long filenames cause the compiler to emit the "file name too long" error, even though previous versions of the compiler would not have done so. (link)
  • Using std::map with braces in a return statement can cause internal compiler errors. (link)
  • Variadic templates can cause internal compiler errors. (link, link)
  • The compiler rejects correct boost:fusion code. (link)
  • GUID generation behaves incorrectly for TypedEventHandler.
  • The compiler incorrectly rejects the use of initializer lists as default function arguments. (link, link)
  • Internal compiler error.

Thanks to everyone who provided feedback!

  • Any word on loop-interchange optimization and loop-hoisting optimization: stackoverflow.com/.../11227809 ? If you venture a guess, do you see it coming in this century?

    Do the compiler optimization guys share their secret recipes with .NET, ".NET native" and JavaScript teams?

    I think there are enormous commonalities which can be considered for all these programming platforms. Loop-interchange and loop-invariant hoisting being the top of the list..

    This is exactly what Apple and Google are doing with their compilers.... collaborating the knowledge followed by quick releases... no holding back! Unfortunately the only two people working at Microsoft on JavaScript compiler are too busy to learn tricks and tips explored by the big boys at VC compiler optimization teams. Hence no performance improvement in IE whatsoever.. Too much for nothing eh!

  • Cool, thanks! I think _thats_ what the community was expecting for a long time as part of the release notes - a comprehensive list of bugfixes! As opposed to "Update 2:  Some C++ compiler crashes and language conformance issues have been addressed." PLEASE! do continue that for all future updates and service packs of VS. We are all developers, not offices users, we can handle such a list, we want such a list!

  • Agreed, that's a fine move, Eric.

    Nice to see so many variadic template compiler-related issues resolved.

    Thank's for sharing this with us :-)

  • It's good to see that my bug is fixed too ;-) (806758, unlisted above, but perhaps it's a duplicate)

  • Thank you very much for the detailed list! Wow, there are some bugfixes I didn't expect in a VC12 update.

  • Thanks, Eric! Does Visual Studio 2013 Update 2 also include the bug fix of "Initializer lists leaking memory", connect.microsoft.com/.../807419 ?  It seems so, as I cannot reproduce that memory leak anymore, while I could with Update 1.

  • @Niels, yes it does!

  • @Super Mario: I'm on the CLR team and am the owner of .NET Native. Yes, the C++ compiler team absolutely shares their secret recipes with .NET. In fact, .NET Native uses the C++ optimizer (N-UTC) to create our binaries.

    We talk with the C++ team all the time and we definitely work with the folks on the JavaScript compiler. In fact, I was on the C++ team a few years back with four of the people working on the JavaScript compiler.

  • @Andrew Pardoe [MSFT],

    I am so glad to know that! Thanks for sharing with us. Please share your thoughts on Loop-interchange and loop-invariant hoisting optimizations and how compiler optimization guys are planning to go about them. I have read some material available online on this subject and few clues about how Intel compiler guys have managed to implement it.

    The question I referred to is the top question on SO community. Masses will be queuing to learn about your progress in that dimension.

    Unfortunately, after all these effort Internet Explorer lags (at least 500 times behind Chrome, Safari and Firefox) in DOM manipulation test written in 2003 by one of the Google employee: http://jsfiddle.net/XPqdS/ (button press) and http://jsfiddle.net/LQMdC/ (on document load). They are extremely basic code structs (and common in all mustache family languages). But apparently IE are still acting on fair-enough strategy rather than aggressively and greedily eking out performance advantages with new explorations; be it a millisecond of performance gain, its still a gain. If others can do it in 10 ms or so, we would expect MSFT product to calculate in less than 10 ms (given all the experience and brilliance you guys have)! But here we are at >1200ms mark.

  • Template specialization on variadic function arguments can cause internal compiler errors. (link)

    Variadic templates can cause internal compiler errors.

    These seem to be not entirely fixed, I raised a bug report some months ago. Code works fine on gcc. (827051)

    Very disappointed.

Page 1 of 1 (10 items)