{"id":93081,"date":"2016-02-24T07:00:00","date_gmt":"2016-02-24T22:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/oldnewthing\/?p=93081"},"modified":"2019-03-13T10:30:44","modified_gmt":"2019-03-13T17:30:44","slug":"20160224-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20160224-00\/?p=93081","title":{"rendered":"A static_cast is not always just a pointer adjustment"},"content":{"rendered":"

Even without considering virtual base classes, a static_cast<\/code> to move between a base class and a derived class can be more than just a pointer adjustment. <\/p>\n

Consider the following classes and functions. <\/p>\n

\nclass A\n{\npublic:\n int a;\n void DoSomethingA();\n};\n\nclass B\n{\npublic:\n int b;\n void DoSomethingB();\n};\n\nclass C : public A, public B\n{\npublic:\n int c;\n void DoSomethingC();\n};\n\nB* GetB(C* c)\n{\n return static_cast<B*>(c);\n}\n\nvoid AcceptB(B* b);\n\nvoid AcceptC(C* c)\n{\n AcceptB(c);\n}\n<\/pre>\n
Suppose the compiler decided to lay out the memory for C<\/code> like this: <\/p>\n\n\n\n\n
int a;<\/code><\/td>\n} A<\/code><\/td>\n}<\/td>\nC<\/code><\/td>\n<\/tr>\n
int b;<\/code><\/td>\n} B<\/code><\/td>\n<\/tr>\n
int c;<\/code><\/td>\n<\/td>\n<\/tr>\n<\/table>\n
Now, you would think that converting a pointer to a C<\/code> into a pointer to a B<\/code> would be a simple matter of adding sizeof(int)<\/code>, since that’s what you need to do to get from the a<\/code> to the b<\/code>. <\/p>\n
Unless you happen to have started with a null pointer. <\/p>\n
The rule for null pointers is that casting a null pointer to anything results in another null pointer. <\/p>\n
This means that if the parameter to GetB<\/code> is a null pointer, the function cannot return nullptr + sizeof(int)<\/code>; it has to return nullptr<\/code>. <\/p>\n
\nGetB:\n    xor rax, rax\n    test rcx, rcx\n    jz @F\n    lea rax, [rcx+sizeof(int)]\n@@: ret\n<\/pre>\n
Similarly, if the parameter to AcceptC<\/code> is nullptr<\/code>, then it must call AcceptB<\/code> with nullptr<\/code>. <\/p>\n
\nAcceptC:\n    test rcx, rcx\n    jz   @F\n    add  rcx, sizeof(int)\n@@: jmp  AcceptB\n<\/pre>\n
A naïve compiler would insert all these conditional jumps every time you cast between a base class and a derived class that involves an adjustment. But this is also a case where a compiler that takes advantage of undefined behavior<\/a> can optimize the test away<\/a>: If it sees that every code path through the static_cast<\/code> dereferences either the upcast or downcast pointer, then that means that if the pointer being converted were nullptr<\/code>, it would result in undefined behavior. Therefore, the compiler can assume that the pointer is never nullptr<\/code> and remove the test. <\/p>\n
\nvoid AcceptC2(C* c)\n{\n c->DoSomethingB();\n}\n<\/pre>\n
Here, the test can be elided because the result of the conversion is immediate dereferenced in order to call the B::Do­SomethingB<\/code> method. The C++ language says that if you try to call an instance method on a null pointer, the behavior is undefined. Doesn’t matter whether the method actually accesses any member variables; just the fact that you invoked an instance method is enough to guarantee that the pointer is not null. Therefore, the AcceptC2<\/code> function compiles to <\/p>\n
\nAcceptC2:\n    add rcx, sizeof(int)\n    jmp B::DoSomethingB\n<\/pre>\n
The same logic applies on the receiving end of the method call: A method call can assume that this<\/code> is never null. <\/p>\n
\nvoid C::DoSomethingC()\n{\n AcceptB(this);\n}\n\nC::DoSomethingC:\n    add rcx, sizeof(int)\n    jmp AcceptB\n<\/pre>\n
Since this<\/code> is never null, the conversion from C*<\/code> to B*<\/code> can elide the test and perform the adjustment unconditionally. <\/p>\n
This means that you could add a dummy method to ever class: <\/p>\n
\nclass C : public A, public B\n{\npublic:\n void IsNotNull() { }<\/font>\n int c;\n void DoSomethingC();\n};\n<\/pre>\n
and call c->IsNotNull()<\/code> to tell the compiler, “I guarantee on penalty of undefined behavior that c<\/code> is not null.” <\/p>\n
\nvoid AcceptC3(C* c)\n{\n c->IsNotNull();\n AcceptB(c);\n}\n\nAcceptC3:\n    add rcx, sizeof(int)\n    jmp AcceptB\n<\/pre>\n
I don’t know whether any compilers actually take advantage of this hint, but at least this is a way of providing it in a standard-conforming way. <\/p>\n
Now, it looks like the purpose of this article is to delve into optimization tweaking in order to remove unwanted tests, but that wasn’t actually the point. The point of the article was to explain what these tests are for. You’ll be stepping through some code, and you’ll see these strange tests against zero, so here’s an explanation of why those tests are there. <\/p>\n","protected":false},"excerpt":{"rendered":"
That null pointer thingie.<\/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":[25],"class_list":["post-93081","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
That null pointer thingie.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/93081","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=93081"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/93081\/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=93081"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=93081"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=93081"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}