Ah so I tested. Results (on my x86-64 computer):
```rust
test bench_shift32 ... bench:      3045 ns/iter (+/- 192)
test bench_shift64 ... bench:      3723 ns/iter (+/- 253)
test bench_trans32 ... bench:      3047 ns/iter (+/- 128)
test bench_trans64 ... bench:      3047 ns/iter (+/- 133)
```

Source:
```rust
extern mod extra;
extern mod black_box;

use black_box::{black_box32, black_box64};
use extra::test::BenchHarness;

pub fn trans32(x: u32) -> [u8, .. 4] {
    unsafe { std::cast::transmute(x) }
}
pub fn shift32(x: u32) -> [u8, .. 4] {
    [(x >>  0) as u8, (x >>  8) as u8,
     (x >> 16) as u8, (x >> 24) as u8]
}

pub fn trans64(x: u64) -> [u8, .. 8] {
    unsafe { std::cast::transmute(x) }
}
pub fn shift64(x: u64) -> [u8, .. 8] {
    [(x >>  0) as u8, (x >>  8) as u8,
     (x >> 16) as u8, (x >> 24) as u8,
     (x >> 32) as u8, (x >> 40) as u8,
     (x >> 48) as u8, (x >> 56) as u8]
}

#[bench]
fn bench_trans32(bh: &mut BenchHarness) {
    bh.iter(|| { for i in range(0u32, 1000) { black_box32(trans32(i)) } })
}
#[bench]
fn bench_shift32(bh: &mut BenchHarness) {
    bh.iter(|| { for i in range(0u32, 1000) { black_box32(shift32(i)) } })
}
#[bench]
fn bench_trans64(bh: &mut BenchHarness) {
    bh.iter(|| { for i in range(0u64, 1000) { black_box64(trans64(i)) } })
}
#[bench]
fn bench_shift64(bh: &mut BenchHarness) {
    bh.iter(|| { for i in range(0u64, 1000) { black_box64(shift64(i)) } })
}
```

With a silly external crate to avoid LLVM removing the loop entirely:

```rust
#[inline(never)]
pub fn black_box32(_: [u8, .. 4]) {}
#[inline(never)]
pub fn black_box64(_: [u8, .. 8]) {}
```