{"id":111002,"date":"2025-03-26T07:00:00","date_gmt":"2025-03-26T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=111002"},"modified":"2025-03-26T11:17:57","modified_gmt":"2025-03-26T18:17:57","slug":"20250326-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20250326-00\/?p=111002","title":{"rendered":"Why does INVALID_HANDLE_VALUE<\/CODE> cast through a LONG_PTR<\/CODE> first?"},"content":{"rendered":"

The definition of INVALID_HANDLE_VALUE is<\/p>\n

#define INVALID_HANDLE_VALUE ((HANDLE)(LONG_PTR)-1)\r\n<\/pre>\n
Why is there an extra cast of LONG_PTR<\/code>? Why not just go straight to the final answer?<\/p>\n
#define INVALID_HANDLE_VALUE ((HANDLE)-1)\r\n<\/pre>\n
One clue is that 32-bit Windows did use that simpler definition.<\/p>\n
That clue tells us that the answer has something to do with 64-bit programming.<\/p>\n
The issue is that casting a 32-bit integer to a 64-bit pointer involves two operations: Upgrading the 32-bit value to a 64-bit value, and then treating that 64-bit value as a pointer. The C and C++ languages leave the “interpreting an integer as a pointer” as an implementation-defined operation, but at least if the integer is a 64-bit integer and the pointer is a 64-bit pointer, there is only one reasonable implementation, and that is just to take the integer bit pattern and use it as a pointer.<\/p>\n
The problem is that if the integer is a 32-bit integer and the pointer is a 64-bit pointer, then multiple implementations might make sense. One might be to zero-extend the 32-bit value to a 64-bit value, which might be preferred on  systems that do zero extension naturally. Another would be to sign-extend the 32-bit value to a 64-bit value, which might be preferred on systems that do sign extension naturally. Or it might be to extend based on the signed-ness of the 32-bit value, which might be preferred on systems that can do both types of extensions with equal facility.<\/p>\n
Since there are multiple reasonable but conflicting choices that could be made by an implementation, we should avoid casting a 32-bit integer to a 64-bit pointer because we’re not sure what we’re going to get.<\/p>\n
What we want is a pointer-sized value that has all bits set. So we start with the 32-bit signed integer -1<\/tt> and cast it to a LONG_PTR<\/code>, which makes it a pointer-sized signed integer. Then we cast that pointer-sized integer to a pointer, which in any reasonable implementation would be a reinterpretation with no change in value.<\/p>\n
In other words, the extra cast forces the compiler down the desired path.<\/p>\n\n\n\n\n\n\n\n
 <\/td>\nFFFFFFFF<\/tt><\/td>\n\u00a0<\/td>\n-1<\/tt><\/td>\n<\/tr>\n
 <\/td>\n\u2193<\/td>\n\u00a0<\/td>\nsign extension required by language rules<\/td>\n<\/tr>\n
FFFFFFFF<\/tt><\/td>\nFFFFFFFF<\/tt><\/td>\n\u00a0<\/td>\n(LONG_PTR)-1<\/tt><\/td>\n<\/tr>\n
\u2193<\/td>\n\u00a0<\/td>\nonly reasonable implementation<\/td>\n<\/tr>\n
FFFFFFFF<\/tt><\/td>\nFFFFFFFF<\/tt><\/td>\n\u00a0<\/td>\n(HANDLE)(LONG_PTR)-1<\/tt><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
If we had omitted the cast to LONG_PTR<\/code>, then we would lose control over the upper 32 bits.<\/p>\n\n\n\n\n\n
 <\/td>\nFFFFFFFF<\/tt><\/td>\n\u00a0<\/td>\n-1<\/tt><\/td>\n<\/tr>\n
 <\/td>\n\u2193<\/td>\n\u00a0<\/td>\nno control over how 32-bit value becomes a 64-bit value<\/td>\n<\/tr>\n
????????<\/tt><\/td>\nFFFFFFFF<\/tt><\/td>\n\u00a0<\/td>\n(HANDLE)-1<\/tt><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
As a general rule, therefore, casts between pointers and 32-bit integers are mediated by 64-bit integers so that we can control whether the values are sign-extended or zero-extended. We saw a little while ago that  different processors have different preferences on how 32-bit values are extended to 64-bit values<\/a>, so we can’t leave this up to chance.<\/p>\n
Once this rule is in place, we can activate compiler warnings that trigger when you perform casts between 32-bit integers and 64-bit pointers. These are usually indications of old 32-bit code that is not 64-bit ready. In the case that the integer is a variable or a function return value, the fix is to upgrade the variable or function to return a 64-bit integer so that the upper 32 bits of pointers are not lost. In the case that the integer is just being smuggled inside a pointer, insert an explicit cast to a 64-bit value to indicate that you don’t actually have a pointer at all; you just want to create a pointer with a specific bit pattern.<\/p>\n","protected":false},"excerpt":{"rendered":"
To ensure that the proper sign extension happens.<\/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":[],"class_list":["post-111002","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing"],"acf":[],"blog_post_summary":"
To ensure that the proper sign extension happens.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/111002","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=111002"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/111002\/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=111002"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=111002"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=111002"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}