What does i = * ( long * ) &y; do?

Question

I saw following code here.

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking
    i  = 0x5f3759df - ( i >> 1 );               // what the heck? 
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}

I don't understand following line.

i  = * ( long * ) &y;

Generally, we use * and & with pointer, but here both used with variable. So, what does it do here?

@Jean-FrançoisFabre I didn't think about getting the bits for the exp quickly that way, pretty neat. — kabanus, Dec 22 '17 at 20:01
it violently memcpys the float to long to do some magic mask & shifting. I linked to a SO question which somehow explains — Jean-François Fabre, Dec 22 '17 at 20:02
`float x2, y;... i = * ( long * ) &y; ` is undefined behavior. Use a `union`. — chux - Reinstate Monica, Dec 22 '17 at 20:05
@DanielH and so that old code is likely still good with old C compilers running on old platforms. Likely neither of those apply for OP. — chux - Reinstate Monica, Dec 22 '17 at 20:06
See also the explanation of "undefined behavior" here: https://stackoverflow.com/questions/2397984/undefined-unspecified-and-implementation-defined-behavior — Robᵩ, Dec 22 '17 at 20:08
See this post on Reddit: https://www.reddit.com/r/todayilearned/comments/3xyo0t/til_quake_iii_arena_needing_to_calculate_x12/ — Sardar Usama, Dec 22 '17 at 20:12
@Daniel H, Sounds backwards. Memory alignment restrictions is not a new thing. — ikegami, Dec 22 '17 at 20:24
@ikegami I think the strict aliasing rule was implemented in C99. This algorithm is newer than I thought, and also from 1999. — Daniel H, Dec 22 '17 at 20:27
@chux I doubt the OP is trying to use this code, just understand it. It doesn’t even work on a lot of modern systems, where `long` is 64-bits, whether or not you have strict aliasing turned off. — Daniel H, Dec 22 '17 at 20:29
@Daniel H, But memory alignment issues predate C99 by a lot, and that code can fail because of memory alignment issues. I don't know if that counts as undefined behaviour, but it might as well count since the result is the same. — ikegami, Dec 22 '17 at 20:29
@ikegami Bad memory alignment is UB, but I think `float`s usually have 4-byte alignment and the stack is usually more aligned than that anyway so it doesn’t matter. — Daniel H, Dec 22 '17 at 20:32
The code "works" be cause of UB (a lot of UB). It is that the author's use resulted in a nice UB. — chux - Reinstate Monica, Dec 22 '17 at 20:35
@chux Even if the original code used C99 and the type punning was UB, it’s the only UB I see; that’s not “a lot of UB”. It depends on the sizes, alignments, and representations of `float` and `long`, which are implementation-defined. It’s not portable, but that isn’t a synonym for undefined behavior. — Daniel H, Dec 22 '17 at 20:39
@DanielH I agree with your "it’s the only UB I see". Yet we are venturing OT. — chux - Reinstate Monica, Dec 22 '17 at 20:58

score 5 · Accepted Answer · answered Dec 22 '17 at 20:03

5

The line is taking a float, looking at the memory holding that float, reinterpreting that memory as memory holding a long, and getting that long. Basically, it's reinterpreting the bit-pattern of a floating point number as that of an integer, in order to mess around with its bits.

Unfortunately, that code is also wrong. You are not allowed to dereference that casted pointer, for reasons described here. In C, the one-and-only way of reinterpreting a bit pattern is through memcpy. (Depending on C variant and implementation, going through a union may be acceptable as well.)

answered Dec 22 '17 at 20:03

Sneftel

40,271
12
71
104

Can you give a quick explanation on the major difference between a memcopy and doing the cast straight away (not through addressing)? – kabanus Dec 22 '17 at 20:06
@kabanus What do you mean by "doing the cast straight away"? – Sneftel Dec 22 '17 at 20:06
I mean `i=(long)y` – kabanus Dec 22 '17 at 20:07
1

@kabanus The difference is that in `(long)y`, a number is being converted. In the OP's case, a *memory address* is being converted. You're telling the compiler "you know that memory address? Pretend that the data there is an integer, not a float". Of course it isn't really, so the value you get out will be as much about how floating point numbers are represented as it is about what the number in question actually *was*. – Sneftel Dec 22 '17 at 20:10
Thanks, and I think that's worth to put in the answer. NM, I see this was closed :) – kabanus Dec 22 '17 at 20:14
I’m pretty sure the C standard still allows unions for type punning; I think it’s only C++ that prohibits them. – Daniel H Dec 22 '17 at 20:30
1

@DanielH C99 does, but C89 was cagey about it. – Sneftel Dec 22 '17 at 20:33

score 2 · Answer 2 · answered Dec 22 '17 at 20:07

First, a disclaimer: This is technically undefined behavior because it violates the strict aliasing rule, but most compilers will do the below, and I don’t know what the standards situation was when this was first written.

When you look at the expression, there are four main parts:(

y is the float variable we want to convert. Simple enough.
& is the usual address-of operator, so &y is a pointer to y.
(long *) is a cast to a pointer to long, so (long *) &y is a pointer-to-long pointing to the same location in memory as y is at. There is no real long there, just a float, but if both float and long are 32 bits (like the code assumes), this will give you a pointer to a long with the same bit pattern as a float.
Finally, * dereferences the pointer. Thus, the full expression, * ( long * ) &y;, gives you a long with same bit pattern as y.

Usually, a long with the same bit pattern as a float would be useless, because they store numbers in completely different ways. However, it’s easier to do bit manipulation to a long, and the program later converts it back to a `float.

David Hoelzer · Answer 3 · 2017-12-23T01:48:45.980

0

It means the address of y (making it a pointer) cast to a long pointer, dereferenced and assigned to i.

edited Dec 23 '17 at 01:48

answered Dec 22 '17 at 20:02

David Hoelzer

15,862
4
48
67

1

[There isn't really a spiral rule.](https://stackoverflow.com/questions/16260417/the-spiral-rule-about-declarations-when-is-it-in-error) There also isn't a spiral in this particular case. – Oliver Charlesworth Dec 22 '17 at 20:13
To clarify @OliverCharlesworth’s comment, the spiral rule is a simplification of the actual C++ type-parsing rules. Since it’s a simplification, there are a lot of cases where the spiral rule gives the wrong answer. In any case, it’s only for parsing types, not expressions. – Daniel H Dec 22 '17 at 23:42

What does i = * ( long * ) &y; do?

3 Answers3

Linked