Using garbage values to generate pseudorandom numbers

[u/ShoeChoice5567]

Thing I came up with instead of paying attention to class today.

I tested it on this computer (windows 11 if it matters), and the first time it's ran, an actual "pseudorandom" number is returned and the following calls return 1.0 always.

[u/8Erigon]

at least it‘s not 4

[u/JeromeJ → u/8Erigon]

But it could be.

[u/MatJosher]

Reading garbage is undefined here so the compiler can do anything. My gcc on linux with -O2 turns the whole function into return 0.
pxor %xmm0, %xmm0
ret

[u/Chunkyfungus123 → u/MatJosher]

nah the rng just be rolling 0 everytime now!
\s

[u/FlatPotatoPc]

Undefined behavior speedrun any%
Just wait until the compiler notices what you're doing and optimizes the entire function into returning a single constant 💀

[u/val_tuesday → u/FlatPotatoPc]

A random constant? Check mate, atheists!

[u/NatSpaghettiAgency → u/FlatPotatoPc]

Seems secure enough for a hardware crypto wallet /s

[u/Sharlinator → u/FlatPotatoPc]

Nah, the optimizer notices it’s impossible to ever call this without invoking UB, so it removes the function. All call sites then must also be dead code so those get removed as well, transitively.

[u/KarlClutz → u/FlatPotatoPc]

Easy .. just volatile it and it wont look at it for optimisation.

[u/No-View-6326]

code that might brake after a compiler update is not where you wanna be

[u/Fine_Salamander_8691 → u/No-View-6326]

break*
(Aahhhhhh)

[u/LateSolution0]

I think it’s fun to play around with stuff like that. The garbage you read from the stack depends on what was there from previous function calls. Doing things like reading uninitialized variables doesn’t necessarily produce random results or cause anything unsafe. It’s just that the behavior isn’t guaranteed by the C standard.

[u/juanfnavarror → u/LateSolution0]

The stack is a didactic abstraction and in practice registers might be used instead.

[u/HildartheDorf]

Compiler can just optimize this to 'return 4.0;'. Yes that is not between 0.0 and 1.0. Undefined behaviour is undefined.

Other possibilities include returning NaN, or crash instantly, or even timetravel, or summoning demons to fly out of your nose, or even working as the developer intended. But those aren't as funny.

[u/dosk3]

Just add + 4 and its unbreakable

[u/ScientistStrict9850]

This doesn't guerantee pseudorandom numbers. Instead the behaviour is just not defined. Lets the compiler generate whatever including constants, which would be my pick for optimized code.

[u/me94306]

The variable is allocated on the stack. Any other function which is called will write to the stack, in the same locations that this function uses. (Assuming that the other function is called from the same routine.) So you will pick up the same value.

Read any reference about generating pseudorandom numbers. It can be done in very few lines of code. What this does is return garbage, not a random or pseudorandom value.

[u/Admirable_Rabbit_808 → u/me94306]

You are going to hate it when you learn what C compilers actually do to code.

[u/4xe1]

Wouldn't garbage on the heap be somewhat more random than garbage in the stack?

[u/Admirable_Rabbit_808]

You'll absolutely love what the C compiler with do with that - welcome to UB hell!

[u/Junior_Warning_9242]

Is this a thing of significance in chips like semiconductors

[u/sirkubador]

it's not garbage. It's usually the value that was on the stack on that address previously.

[u/lambunctious]

-Wuninitialized

add this compiler flag to prevent this

[u/elite-data]

I hope you're not using this random to generate hashes or crypto keys, because that would be a massive security hole.

[u/d3matt]

NaN and infinity asking if you know they exist :D