{"id":107601,"date":"2022-12-19T07:00:00","date_gmt":"2022-12-19T15:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=107601"},"modified":"2022-12-15T15:55:07","modified_gmt":"2022-12-15T23:55:07","slug":"20221219-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20221219-00\/?p=107601","title":{"rendered":"On the large number of ways of expressing Microsoft Visual C++ compiler versions"},"content":{"rendered":"

When you ask someone what version of the Microsoft Visual C++ compiler they’re using, or if somebody tells you “This feature requires version X of the Microsoft Visual C++ compiler”, you can get the answer is a large number of ways, because the Microsoft Visual C++ compiler has apparently decided that if one version number is good, then more must be better.<\/p>\n

The first version number that enters the picture is the name of the Visual Studio product the compiler comes with. This is probably something like “Visual Studio YYYY” for some year, like “Visual Studio 2019”.<\/p>\n

The next version number is the product version of that Visual Studio product. For example, “Visual Studio 2019 version 16.11.”<\/p>\n

The next version number is the platform toolset that you specify in your project file, like <PlatformToolset>v142<\/PlatformToolset><\/code>.<\/p>\n

Another version number is the actual toolchain version, like “14.29”.<\/p>\n

And then there’s the version number reported by the _MSC_VER<\/code> predefined macro, like “1929”.<\/p>\n

On top of that is the version number reported by the _MSC_FULL_VER<\/code> predefined macro, like “192930100”.<\/p>\n

And finally, there’s the version number reported by the compiler itself when you type cl \/?<\/code>.<\/p>\n

How are all of these version numbers related?<\/p>\n\n\n\n
Product name<\/td>\n?
\n\u21d4<\/td>\n		Product version<\/td>\n?
\n\u21d4<\/td>\n		Platform toolset<\/td>\n?
\n\u21d4<\/td>\n		Toolchain<\/td>\n?
\n\u21d4<\/td>\n		_MSC_VER<\/code><\/td>\n?
\n\u21d4<\/td>\n		_MSC_FULL_VER<\/code><\/td>\n?
\n\u21d4<\/td>\n		Compiler banner<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Okay, let’s do the easy one first: The last three version numbers are related to each other in a straightforward way<\/a>. If the compiler’s self-reported version is aa.bb.ccccc.dd<\/code>, then the _MSC_VER<\/code> is aabb<\/code> and the _MSC_FULL_VER<\/code> is aabbccccc<\/code>. In other words, _MSC_VER = aa * 100 + bb<\/code> and _MSC_FULL_VER = aa * 10000000 + bb * 100000 + cc<\/code> .<\/p>\n

Okay, so that lets us build a relationship among the last three boxes: The compiler banner is the basis for the other two.<\/p>\n

The first two boxes are also related, but in a less obvious way: The product name and product major version line up according to this table on Wikipedia<\/a>. For example, Visual Studio 2019 corresponds to product versions 16.*.<\/p>\n

The next two boxes also appear to be related, although I can’t find any official documentation to that effect. The platform toolset appears to be the letter “v”, followed by the toolchain major version, followed by the first digit of the minor version. For example, a toolchain version of “14.29” corresponds to a platform toolset of “v142”.<\/p>\n

That leaves three major categories: The Visual Studio product, the toolchain, and the compiler. These three categories follow their own path, so you have to use a cheat sheet to see how they correspond to each other.\u00b9<\/p>\n

Let’s build that cheat sheet. I got the raw data from this table on Wikipedia<\/a>, with gaps filled in from the archived Visual Studio release notes<\/a>.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Name<\/th>\nProduct<\/th>\nToolset<\/th>\nToolchain<\/th>\n_MSC_
\nVER<\/code><\/th>\n		_MSC_
\nFULL_VER<\/code><\/th>\n		Compiler<\/th>\n<\/tr>\n
Visual
\nStudio
\n2017<\/td>\n		15.0<\/td>\nv141<\/td>\n14.1<\/td>\n1910<\/td>\n1910xxxxx<\/td>\n19.10.xxxxx<\/td>\n<\/tr>\n
15.1<\/td>\n<\/tr>\n
15.2<\/td>\n<\/tr>\n
15.3<\/td>\n14.11<\/td>\n1911<\/td>\n1911xxxxx<\/td>\n19.11.xxxxx<\/td>\n<\/tr>\n
15.4<\/td>\n<\/tr>\n
15.5<\/td>\n14.12<\/td>\n1912<\/td>\n1912xxxxx<\/td>\n19.12.xxxxx<\/td>\n<\/tr>\n
15.6<\/td>\n14.13<\/td>\n1913<\/td>\n1913xxxxx<\/td>\n19.13.xxxxx<\/td>\n<\/tr>\n
15.7<\/td>\n14.14<\/td>\n1914<\/td>\n1914xxxxx<\/td>\n19.14.xxxxx<\/td>\n<\/tr>\n
15.8<\/td>\n14.15<\/td>\n1915<\/td>\n1915xxxxx<\/td>\n19.15.xxxxx<\/td>\n<\/tr>\n
15.9<\/td>\n14.16<\/td>\n1916<\/td>\n1916xxxxx<\/td>\n19.16.xxxxx<\/td>\n<\/tr>\n
Visual
\nStudio
\n2019<\/td>\n		16.0<\/td>\nv142<\/td>\n14.20<\/td>\n1920<\/td>\n1920xxxxx<\/td>\n19.20.xxxxx<\/td>\n<\/tr>\n
16.1<\/td>\n14.21<\/td>\n1921<\/td>\n1921xxxxx<\/td>\n19.21.xxxxx<\/td>\n<\/tr>\n
16.2<\/td>\n14.22<\/td>\n1922<\/td>\n1922xxxxx<\/td>\n19.22.xxxxx<\/td>\n<\/tr>\n
16.3<\/td>\n14.23<\/td>\n1923<\/td>\n1923xxxxx<\/td>\n19.23.xxxxx<\/td>\n<\/tr>\n
16.4<\/td>\n14.24<\/td>\n1924<\/td>\n1924xxxxx<\/td>\n19.24.xxxxx<\/td>\n<\/tr>\n
16.5<\/td>\n14.25<\/td>\n1925<\/td>\n1925xxxxx<\/td>\n19.25.xxxxx<\/td>\n<\/tr>\n
16.6<\/td>\n14.26<\/td>\n1926<\/td>\n1926xxxxx<\/td>\n19.26.xxxxx<\/td>\n<\/tr>\n
16.7<\/td>\n14.27<\/td>\n1927<\/td>\n1927xxxxx<\/td>\n19.27.xxxxx<\/td>\n<\/tr>\n
16.8<\/td>\n14.28<\/td>\n1928<\/td>\n1928xxxxx<\/td>\n19.28.xxxxx<\/td>\n<\/tr>\n
16.9<\/td>\n<\/tr>\n
16.10<\/td>\n14.29<\/td>\n1929<\/td>\n1929xxxxx<\/td>\n19.29.xxxxx<\/td>\n<\/tr>\n
16.11<\/td>\n<\/tr>\n
Visual
\nStudio
\n2022<\/td>\n		17.0<\/td>\nv143<\/td>\n14.30<\/td>\n1930<\/td>\n1930xxxxx<\/td>\n19.30.xxxxx<\/td>\n<\/tr>\n
17.1<\/td>\n14.31<\/td>\n1931<\/td>\n1931xxxxx<\/td>\n19.31.xxxxx<\/td>\n<\/tr>\n
17.2<\/td>\n14.32<\/td>\n1932<\/td>\n1932xxxxx<\/td>\n19.32.xxxxx<\/td>\n<\/tr>\n
17.3<\/td>\n14.33<\/td>\n1933<\/td>\n1933xxxxx<\/td>\n19.33.xxxxx<\/td>\n<\/tr>\n
17.4<\/td>\n14.34<\/td>\n1934<\/td>\n1934xxxxx<\/td>\n19.34.xxxxx<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

But wait, the story isn’t over yet.<\/p>\n

Internally, the compiler team delivers periodic compiler updates to the Windows team. These updates are named LKG followed by a number, like “LKG14”, and there is an internal Web site that maps LKG values to compiler version numbers. Fortunately, only people who work at Microsoft need to worry about these LKG version numbers.<\/p>\n

Bonus chatter<\/b>: The term LKG stands for “Last Known Good”, meaning that it is the latest version of the compiler that has been validated against the Windows code base. There is another term FKG, which you think might stand for “First Known Good”, but it doesn’t. It originally stood for “Fast Known Good” because it contained compilers even newer than the Last Known Good. That policy has changed, and now the FKG is used for other purposes, but the name FKG stuck, even though it’s completely wrong.<\/p>\n

\u00b9 It appears that starting in Visual Studio 2017, the compiler minor version increases by one each time the toolchain minor version increases by one, so that’s handy. Starting in August 2017, the compiler version is equal to the toolchain version plus five. I don’t know whether this is a rule or a coincidence.<\/p>\n","protected":false},"excerpt":{"rendered":"

So many version numbers.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[26],"class_list":["post-107601","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-other"],"acf":[],"blog_post_summary":"

So many version numbers.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/107601","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=107601"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/107601\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=107601"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=107601"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=107601"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}