Four different outcomes when overflowing main stack - memory

Question

Out of curiosity, I was playing with overflowing the the stack with this code:
fn main() {
let my_array: [i32; 3000000000] = [3; 3000000000];
println!("{}", my_array[0]);
}
And to my surprise I ended with three different outcomes:
1) This is what I expected:
thread '<main>' has overflowed its stack
Illegal instruction (core dumped)
2) Surprisingly vague:
Illegal instruction (core dumped)
3) Totally puzzling:
208333333
In order for stochastic nature to show up I had to restart the shell, otherwise results were deterministic ( I would get the same error message over and over).
I compiled with just:
rustc my_file.rs
and excuted with:
./my_file
My rustc version:
rustc 1.0.0 (a59de37e9 2015-05-13) (built 2015-05-14)
My ubuntu version:
Distributor ID: Ubuntu
Description: Ubuntu 14.04 LTS
Release: 14.04
Codename: trusty
Also the size of the array I am trying to create is 12 gigs, I am on a tiny laptop that does not have that amount of RAM.
Any ideas what could be going on here?
Edit:
I was playing with the size of array (which I think might be the reason for different errors, but why?), and got one more:
4) Makes perfect sense.
error: the type `[i32; 300000000000000]` is too big for the current architecture
and my system architecture is x86_64.

Answer 1

It seems that above randomness is related to my machine.
I checked the same code on another machine, that has the same rustc version, ubuntu version and the same architecture. And my results a much more predictable:
If size of the array 536870871 or greater (without getting to case 4) I get:
Illegal instruction (core dumped)
If size of array is 536870870 or smaller (without being small enough to actually work) I get:
thread '<main>' has overflowed its stack
Illegal instruction (core dumped)
Not a single time have I gotten a case 3) where I had garbage returned.