{"id":7331,"date":"2015-12-02T13:44:00","date_gmt":"2015-12-02T13:44:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vcblog\/2015\/12\/02\/constexpr-in-vs2015-update-1\/"},"modified":"2019-02-18T18:04:54","modified_gmt":"2019-02-18T18:04:54","slug":"constexpr-in-vs2015-update-1","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/constexpr-in-vs2015-update-1\/","title":{"rendered":"Constexpr in VS2015 Update 1"},"content":{"rendered":"

Visual Studio 2015 RTM shipped with support for constant expressions<\/a> as specified in the C++11 language standard. The release received lots of excellent feedback from our users and the C++ community. Using that feedback, we’ve been working on refining our implementation for VS 2015 Update 1. Our goal with VS 2015 Update 1 was to finish up the last significant feature work for C++11 constexpr and improve our implementation’s robustness. This blog post is going to provide some notes to explain where VS 2015 Update 1 puts us and where we’re going with constexpr support.<\/p>\n

Static Initializers<\/h2>\n

VS 2015 shipped with a warning that indicates that the compiler can detect and use initializers for constexpr evaluation but will not statically emit these initializers. That is, although the compiler had enough information to emit fully instantiated types that could be loaded from the compiled executable, it didn’t emit the fully instantiated types. These types were instantiated and constructed at runtime, as most C++ objects traditionally have been.<\/p>\n

The great news is that VS 2015 Update 1 now supports emitting static initializers! These types are fully instantiated when they’re loaded into memory, rather than running the code at runtime to initialize them. This was the last feature that we needed to implement for C++11 constexpr support and we’re excited to ship it with Update 1.<\/p>\n

We should extend kudos to Tanveer Gani for the herculean work he’s done to make this feature ship with Update 1. Because of his work, Update 1 will be shipping with complete support for emitting static initializers for constexpr objects. It will also ship with partial support for constant initialization of objects of non-literal types that have constexpr constructors (as specified in section 3.6.2 of the C++ language standard). Specifically, types with virtual functions aren’t implemented yet.<\/p>\n

Static initializers are an important part of implementing std::once_flag<\/span>, which is used for std::call_once<\/span>. Stephan calls this out in his blog post<\/a> about improvements to the STL in VS 2015 RTM.<\/p>\n

The reduction in code generated by VS 2015 Update 1 for runtime execution can be quite dramatic. I’d like to take some time to explore the behavior with some examples. The C++ source is shown first, followed by assembly code illustrating static initialization. The assembly for these code snippets was generated by invoking the C++ compiler with the \/FAsc<\/span> flag.<\/p>\n

Example 1: Initialization of a Constexpr Object<\/h4>\n

We’ll start with a simple example – constructing a simple instance of a type with a constexpr constructor.<\/p>\n

struct<\/span> Point {<\/span>
    constexpr<\/span> Point(int x1, int y1)<\/span>
    : x(x1), y(y1)<\/span>
    {}<\/span><\/p>\n

    int x;<\/span>
    int y;<\/span>
};<\/span>
constexpr<\/span> Point p1(10, 11);<\/span><\/p>\n

First, the assembly generated by VS 2015 RTM for this snippet (for comparison):<\/p>\n

; VS 2015 RTM asm<\/span>
PUBLIC ??0Point@@QEAA@HH@Z            ; Point::Point<\/span><\/span>
_BSS      SEGMENT<\/span>
?p1@@3UPoint@@B DQ 01H DUP (?)        ; p1<\/span><\/span>
_BSS      ENDS<\/span>
text$di  SEGMENT<\/span>
??__Ep1@@YAXXZ PROC                   ; `dynamic initializer for ‘p1”, COMDAT<\/span><\/span><\/p>\n

; 8    : constexpr Point p1(10, 11);<\/span><\/p>\n

        sub       rsp, 40             ; 00000028H<\/span><\/span>
        mov       r8d, 11<\/span>
        mov       edx, 10<\/span>
        lea       rcx, OFFSET FLAT:?p1@@3UPoint@@B<\/span>
        call      ??0Point@@QEAA@HH@Z ; Point::Point<\/span><\/span>
        add       rsp, 40             ; 00000028H<\/span><\/span>
        ret       0<\/span>
??__Ep1@@YAXXZ ENDP                   ; `dynamic initializer for ‘p1”<\/span><\/span>
text$di  ENDS<\/span><\/p>\n

And now the assembly generated by VS 2015 Update 1:<\/p>\n

; VS 2015 Update 1 asm<\/span>
CONST  SEGMENT<\/span>
?p1@@3UPoint@@B<\/span>
        DD        0aH                 ; p1<\/span><\/span>
        DD        0bH<\/span>
CONST  ENDS<\/span><\/p>\n

Notice that there is no initialization code in the assembly generated by VS 2015 Update 1. Running the C++ code under the Visual Studio debugger in VS 2015 Update 1 will expectedly not execute the constructor for Point.<\/p>\n

Example 2: Initialization of Array of Constexpr Objects<\/h4>\n

Continuing with the definition of Point above, we’ll create an array of Points:<\/p>\n

constexpr<\/span> Point arr[] = { Point(2, 3), Point(5, 7), Point(11, 13) };<\/span><\/p>\n

The generated assembly from VS 2015 Update 1 is excellent:<\/p>\n

; VS 2015 Update 1 asm<\/span>
CONST  SEGMENT<\/span>
?arr@@3QBUPoint@@B<\/span>
                DD          02H  ; arr<\/span><\/span>
                DD          03H<\/span>
                DD          05H<\/span>
                DD          07H<\/span>
                DD          0bH<\/span>
                DD          0dH<\/span>
CONST  ENDS<\/span><\/p>\n

 Example 3: Initializing pointer and reference members of a constexpr object<\/h4>\n

This code snippet initializes a constexpr object with pointers and references to a global constexpr variable.<\/p>\n

constexpr<\/span> int I = 42;
struct<\/span> A {
    const<\/span> int& ref;
    const<\/span> char *ptr;
    const<\/span> char *&ref2;
    constexpr<\/span> A(const<\/span> char *p, const<\/span> int& r)
    : ref(r), ptr(p), ref2{ptr}
    {}
};
constexpr<\/span> A a{ \"qwerty\", I };<\/span><\/pre>\n
This sample actually causes an ICE in VS 2015 RTM, but generates delightfully terse assembly code in VS 2015 Update 1.<\/p>\n
; VS 2015 Update 1 asm<\/span>
CONST  SEGMENT<\/span>
?I@@3HB         DD        02aH<\/span>
?a@@3UA@@B<\/span>
                DD        FLAT:?I@@3HB    ; a<\/span><\/span>
                DD        FLAT:$SG2668<\/span>
                DD        FLAT:?a@@3UA@@B+4<\/span>
$SG2668<\/span>
                DB        ‘qwerty’, 00H<\/span>
CONST  ENDS<\/span><\/p>\n
Example 4: Initializing constexpr classes with base constructors<\/h4>\n
Even classes with complicated (non-virtual) inheritance can be initialized statically. I’m not going to list the VS 2015 RTM as it’s prohibitively long, but you can view the COD file yourself by compiling the snippet below with the \/FAsc<\/span> flag.<\/p>\n
struct<\/span> Empty {};
struct<\/span> A {
     short i;
     constexpr<\/span> A(int ii)
     : i(ii)
     {}
};
struct<\/span> B {
    double d;
    constexpr<\/span> B(double di)
    : d(di)
    {}
};
struct<\/span> C : Empty, A, B {
    double x;
    constexpr<\/span> C()
    : x(1.0), A(42), B(-1.0)
    {}
};
constexpr<\/span> C c;
<\/span><\/span><\/p>\n
And the assembly generated by VS 2015 Update 1:<\/p>\n
; VS 2015 Update 1 asm<\/span>
CONST  SEGMENT<\/span>
?c@@3UC@@B DW       02aH                          ; c<\/span><\/span>
                ORG $+6<\/span>
                DQ          0bff0000000000000r    ; -1<\/span><\/span>
                DQ          03ff0000000000000r    ; 1<\/span><\/span>
CONST  ENDS <\/span><\/pre>\n
 Example 5: Initializing a non-literal type<\/h4>\n
As mentioned above, some non-literal types that are initialized with constants can be statically initialized. In the sample below, the initialized supplied to the constexpr constructor is a constant, so Update 1 can statically initialize it. Note that the type has a destructor, which makes the type a non-literal type.<\/p>\n
extern<\/span> \"C\"<\/span> int<\/span> puts(const<\/span> char<\/span>*);<\/span><\/pre>\n
struct<\/span> NonLiteralType {<\/span><\/pre>\n
const<\/span> char<\/span> *p;<\/span><\/pre>\n
constexpr<\/span> NonLiteralType(const<\/span> char<\/span> *pp)<\/span><\/pre>\n
: p(pp)<\/span><\/pre>\n
{}<\/span><\/pre>\n
 <\/pre>\n
~NonLiteralType() {<\/span><\/pre>\n
puts(\"~NonLiteralType()\"<\/span>);<\/span><\/pre>\n
}<\/span><\/pre>\n
};<\/span><\/pre>\n
NonLiteralType nlt(\"qwerty\"<\/span>);<\/span><\/pre>\n
int<\/span> main(){}<\/span><\/pre>\n
 <\/pre>\n
The assembly generated in Update 1 does not place the object in the CONST segment, because it was not declared constexpr:<\/p>\n
 <\/pre>\n
; VS 2015 Update 1 asm<\/span>
CONST  SEGMENT<\/span>
$SG2669               DB          ‘qwerty’, 00H<\/span>
CONST  ENDS<\/span><\/p>\n
_DATA  SEGMENT<\/span>
?nlt@@3UNonLiteralType@@A DD FLAT:$SG2669     ; nlt<\/span><\/span>
_DATA  ENDS<\/span><\/p>\n
Destruction of the non-literal type object is done with a registered “atexit” function:<\/p>\n
; VS 2015 Update 1 asm<\/span>
CRT$XCU             SEGMENT<\/span>
?nlt$initializer$@@3P6AXXZA DD FLAT:??__Fnlt@@YAXXZ ; nlt$initializer$<\/span><\/span>
CRT$XCU             ENDS<\/span>
CONST  SEGMENT<\/span><\/p>\n
text$yd SEGMENT<\/span>
??__Fnlt@@YAXXZ<\/span>
        PROC ; `dynamic atexit destructor for ‘nlt”, COMDAT<\/span><\/span>
       push      ebp<\/span>
       mov       ebp, esp<\/span>
       mov       ecx, OFFSET ?nlt@@3UNonLiteralType@@A      ; nlt<\/span><\/span>
       call      ??1NonLiteralType@@QAE@XZ ; NonLiteralType::~NonLiteralType<\/span><\/span>
       pop       ebp<\/span>
       ret       0<\/span>
??__Fnlt@@YAXXZ ENDP ; `dynamic atexit destructor for ‘nlt”<\/span>
text$yd ENDS<\/span><\/p>\n
Quality Improvements<\/h2>\n
Alongside the static initializer work, we’ve fixed ~45 bugs related to constexpr usage. The majority of these bugs were reported to us by customers. Because we tried to prioritize customer issues, you should see improvements across the board when writing constexpr code rather than in any particular areas. The table below shows the bugs that we fixed. Thanks to everybody who filed bugs!<\/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\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Title<\/strong><\/td>\nConnect Customer<\/strong><\/td>\nConnectID<\/strong><\/td>\n<\/tr>\n
[constexpr] Using final on the member variable’s class breaks constexpr<\/td>\nAepaerae<\/td>\n1135313<\/td>\n<\/tr>\n
Error C2131 when creating constexpr std::array<\/td>\nAndrey Ashikhmin<\/td>\n1574634<\/td>\n<\/tr>\n
constexpr void pointer variables not treated as constants<\/td>\nanthonyw1<\/td>\n1609590<\/td>\n<\/tr>\n
constexpr failure with std::array<\/td>\nBrandon Kentel<\/td>\n1604956<\/td>\n<\/tr>\n
Constexpr causes Internal Compiler Error<\/td>\ncamhusmj38<\/td>\n1573435<\/td>\n<\/tr>\n
Constexpr causes Internal Compiler Error<\/td>\ncamhusmj38<\/td>\n1570534<\/td>\n<\/tr>\n
Constexpr produces wrong results [compared to LLVM]<\/td>\ncamhusmj38<\/td>\n1300591<\/td>\n<\/tr>\n
Erroneous error C2131: expression did not evaluate to a constant<\/td>\ncamhusmj38<\/td>\n1596224<\/td>\n<\/tr>\n
MSVC 2015 believes constexpr member pointer is not constant<\/td>\nDavid Majnemer<\/td>\n1327934<\/td>\n<\/tr>\n
MSVC 2015 crashes on pointer arithmetic in constexpr context<\/td>\nDavid Majnemer<\/td>\n1420558<\/td>\n<\/tr>\n
MSVC 2015 crashes trying to evaluate constexpr constructor
which initializes a reference<\/td>\n		David Majnemer<\/td>\n1404631<\/td>\n<\/tr>\n
MSVC 2015 crashes trying to evaluate constexpr containing pointer to member function<\/td>\nDavid Majnemer<\/td>\n1327996<\/td>\n<\/tr>\n
MSVC 2015 incorrectly rejects constexpr array of unions access<\/td>\nDavid Majnemer<\/td>\n1323869<\/td>\n<\/tr>\n
MSVC 2015 incorrectly rejects pointer equality in constexpr context<\/td>\nDavid Majnemer<\/td>\n1404624<\/td>\n<\/tr>\n
MSVC 2015 materializes one constant instead of two in constexpr context<\/td>\nDavid Majnemer<\/td>\n1404688<\/td>\n<\/tr>\n
MSVC 2015 rejects initializing constexpr reference to temporary object<\/td>\nDavid Majnemer<\/td>\n1404715<\/td>\n<\/tr>\n
MSVC 2015 rejects lvalue conditional operator of type const int in constexpr context<\/td>\nDavid Majnemer<\/td>\n1404674<\/td>\n<\/tr>\n
MSVC 2015 rejects member pointer comparison in constexpr context<\/td>\nDavid Majnemer<\/td>\n1401241<\/td>\n<\/tr>\n
MSVC2015 rejects valid and accepts invalid constexpr static_cast<\/td>\nDavid Majnemer<\/td>\n1330530<\/td>\n<\/tr>\n
MSVC 2015 will not evaluate function-local static constexpr reference variable to
temporary<\/td>\n		David Majnemer<\/td>\n1404755<\/td>\n<\/tr>\n
Failure to compile with valid use of ‘constexpr’<\/td>\ndn357<\/td>\n1311469<\/td>\n<\/tr>\n
Compiller Failiure in constexpr statement on std::make_array proposal implementation<\/td>\nFelix Petriconi<\/td>\n1494444<\/td>\n<\/tr>\n
`std::integral_constant<>` implicitly-defined default constructor and\/or `operator value_type` not
constexpr<\/td>\n		ildjarn<\/td>\n1497236<\/td>\n<\/tr>\n
Bogus error regarding returning the address of or a reference to a temporary when attempting aggregate initialization inside of a constexpr function<\/td>\nildjarn<\/td>\n1498733<\/td>\n<\/tr>\n
C++ – constexpr does not work with aggregate initialization<\/td>\nildjarn<\/td>\n1572056<\/td>\n<\/tr>\n
C++ – constexpr does not work with delegating constructors<\/td>\nildjarn<\/td>\n1579279<\/td>\n<\/tr>\n
C++ – constexpr static member functions must be fully qualified when called during type definition<\/td>\nildjarn<\/td>\n1579334<\/td>\n<\/tr>\n
C++ – Internal compiler error with constexpr constructor<\/td>\nildjarn<\/td>\n1571950<\/td>\n<\/tr>\n
[constexpr] bug in deducing constexpr of function pointer<\/td>\nkoosw<\/td>\n1378031<\/td>\n<\/tr>\n
Failed in constexpr lambda workaround<\/td>\nmzer0<\/td>\n1673865<\/td>\n<\/tr>\n
VC++2015 RTM – constexpr constructor errors with union members with bitfields<\/td>\nOrvid King<\/td>\n1571281<\/td>\n<\/tr>\n
constexpr and recurring template cause fatal error C1001<\/td>\nPendenaor<\/td>\n1711144<\/td>\n<\/tr>\n
class static constexpr value is 0<\/td>\npmingkr<\/td>\n1384724<\/td>\n<\/tr>\n
constexpr delegating constructor doesn’t compile<\/td>\nQuixotic Labs<\/td>\n1229998<\/td>\n<\/tr>\n
constexpr bug related to “char const*const” parameters<\/td>\nRui Figueira (Cloudgine)<\/td>\n1272743<\/td>\n<\/tr>\n
[constexpr][regression][boost] VC++ internal compiler error for a non-type template instantiation<\/td>\nSasha Sitnikov<\/td>\n1577162<\/td>\n<\/tr>\n
delegating constructor in constexpr ctor won’t compile<\/td>\nsubmitting_bug_reports_is_too_damn_hard<\/td>\n1463556<\/td>\n<\/tr>\n
[Feedback] ICE when compiling this C\/C++ code<\/td>\n <\/td>\n <\/td>\n<\/tr>\n
Bogus error C2131 “expression did not evaluate to a constant” triggered by variadic-recursive constexpr<\/td>\n <\/td>\n <\/td>\n<\/tr>\n
constexpr delegating constructors<\/td>\n <\/td>\n <\/td>\n<\/tr>\n
constexpr template function causes compilation failure with erroneous message when called from within struct template<\/td>\n <\/td>\n <\/td>\n<\/tr>\n
constexpr 4607 ICE triggered by “ptr ? 3 : 4” in a constexpr function<\/td>\n <\/td>\n <\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Looking Forward<\/h2>\n
Even with the improvements to C++11 constexpr that are shipping with update 1, we still have some refinement to do on our implementation. There are ~30 bugs remaining on our backlog in this area, many related to pointers-to-members in constant expressions. There’s some quality work to do around array and string aliasing, and although Tanveer’s done a solid job of readying static initializers, we’re planning for some amount of incoming bug reports related to the change.<\/p>\n
Essentially, all of this means that we’ll still be working on C++11 constexpr for a while longer, but the outstanding work is manageable. Our goal is to wrap this work up in time for the next Visual Studio update. The plan after that is to immediately dive into C++14 constexpr support.<\/p>\n
 <\/p>\n
Cody Miller<\/p>\n
Visual C++ Team<\/p>\n","protected":false},"excerpt":{"rendered":"
Visual Studio 2015 RTM shipped with support for constant expressions as specified in the C++11 language standard. The release received lots of excellent feedback from our users and the C++ community. Using that feedback, we’ve been working on refining our implementation for VS 2015 Update 1. Our goal with VS 2015 Update 1 was to […]<\/p>\n","protected":false},"author":314,"featured_media":35994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-7331","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cplusplus"],"acf":[],"blog_post_summary":"
Visual Studio 2015 RTM shipped with support for constant expressions as specified in the C++11 language standard. The release received lots of excellent feedback from our users and the C++ community. Using that feedback, we’ve been working on refining our implementation for VS 2015 Update 1. Our goal with VS 2015 Update 1 was to […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/7331","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/users\/314"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=7331"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/7331\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/35994"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=7331"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=7331"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=7331"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}