It would always generate PTX to load only a 1-bit integer (`i1`)
from the provided pointer, regardless of the actual size of `T`.
The alignment specified for the load was also based on the pointer's
alignment, not the pointee's alignment.

This commit changes it to:
1. Load the full `llvm_type_of(T)` instead of `i1`.
2. Use the correct alignment of `T` for the load instruction.
3. Removes an incorrect pointer cast that was based on the return
   ABI of `T` rather than the type of the memory being read.

Possibly fixes Rust-GPU#208.

It would always generate PTX to load only a 1-bit integer (`i1`)
from the provided pointer, regardless of the actual size of `T`.
The alignment specified for the load was also based on the pointer's
alignment, not the pointee's alignment.

This commit changes it to:
1. Load the full `llvm_type_of(T)` instead of `i1`.
2. Use the correct alignment of `T` for the load instruction.
3. Removes an incorrect pointer cast that was based on the return
   ABI of `T` rather than the type of the memory being read.

Possibly fixes Rust-GPU#208.

It would always generate PTX to load only a 1-bit integer (`i1`)
from the provided pointer, regardless of the actual size of `T`.
The alignment specified for the load was also based on the pointer's
alignment, not the pointee's alignment.

This commit changes it to:
1. Load the full `llvm_type_of(T)` instead of `i1`.
2. Use the correct alignment of `T` for the load instruction.
3. Removes an incorrect pointer cast that was based on the return
   ABI of `T` rather than the type of the memory being read.

Possibly fixes Rust-GPU#208.

It would always generate PTX to load only a 1-bit integer (`i1`)
from the provided pointer, regardless of the actual size of `T`.
The alignment specified for the load was also based on the pointer's
alignment, not the pointee's alignment.

This commit changes it to:
1. Load the full `llvm_type_of(T)` instead of `i1`.
2. Use the correct alignment of `T` for the load instruction.
3. Removes an incorrect pointer cast that was based on the return
   ABI of `T` rather than the type of the memory being read.

Possibly fixes Rust-GPU#208.

It would always generate PTX to load only a 1-bit integer (`i1`)
from the provided pointer, regardless of the actual size of `T`.
The alignment specified for the load was also based on the pointer's
alignment, not the pointee's alignment.

This commit changes it to:
1. Load the full `llvm_type_of(T)` instead of `i1`.
2. Use the correct alignment of `T` for the load instruction.
3. Removes an incorrect pointer cast that was based on the return
   ABI of `T` rather than the type of the memory being read.

Possibly fixes Rust-GPU#208.

This isn't fuly correct, as ideally we keep track
of what we have put into constant memory and when
it is filled up spill insead of only spilling when
a static is big. But, this is materially better than
what is there.

Fixes Rust-GPU#208.

See also the debugging and discussion in
Rust-GPU#216

This isn't fully correct, as ideally we keep track
of what we have put into constant memory and when
it is filled up spill insead of only spilling when
a static is big. But, this is materially better than
what is there (which is a runtime error).

An argument can be made to just _always_ use global
memory and we don't have to worry about getting the
packing right.

Fixes Rust-GPU#208.

See also the debugging and discussion in
Rust-GPU#216

This isn't fully correct, as ideally we keep track
of what we have put into constant memory and when
it is filled up spill instdead of only spilling when
a static is big. But, this is materially better than
what is there (which is a runtime error).

An argument can be made to just _always_ use global
memory and we don't have to worry about getting the
packing right.

Fixes Rust-GPU#208.

See also the debugging and discussion in
Rust-GPU#216

* Allow address spaces to propagate to LLVM

This looks like it was code that wasn't deleted after the refactor in
decda87

* Spill large statics from constant to global memory

This isn't fully correct, as ideally we keep track
of what we have put into constant memory and when
it is filled up spill instdead of only spilling when
a static is big. But, this is materially better than
what is there (which is a runtime error).

An argument can be made to just _always_ use global
memory and we don't have to worry about getting the
packing right.

Fixes #208.

See also the debugging and discussion in
#216

* Add `--use-constant-memory-space` flag, off by default

* Make it clear that `#[cuda_std::address_space(constant)]` still works

It would always generate PTX to load only a 1-bit integer (`i1`)
from the provided pointer, regardless of the actual size of `T`.
The alignment specified for the load was also based on the pointer's
alignment, not the pointee's alignment.

This commit changes it to:
1. Load the full `llvm_type_of(T)` instead of `i1`.
2. Use the correct alignment of `T` for the load instruction.
3. Removes an incorrect pointer cast that was based on the return
   ABI of `T` rather than the type of the memory being read.

Possibly fixes Rust-GPU#208.