Reorder operands to copy_memory and copy_nonoverlapping_memory

cosmycoder · cosmycoder · commit 8b909882b261 · 2015-04-01T01:37:02.000-04:00
diff --git a/src/aes_gcm.rs b/src/aes_gcm.rs
@@ -33,7 +33,7 @@ impl<'a> AesGcm<'a> {
         // earlier preventing the use of generic CTR mode.
 
         let mut iv = [0u8; 16];
-        copy_memory(&mut iv, nonce);
+        copy_memory(nonce, &mut iv);
         iv[15] = 1u8;
         let mut cipher = ctr(key_size,key,&iv);
         let temp_block = [0u8; 16];
diff --git a/src/blake2b.rs b/src/blake2b.rs
@@ -122,7 +122,7 @@ impl Blake2b {
             key: [0; BLAKE2B_KEYBYTES],
             key_length: key.len() as u8
         };
-        copy_memory(&mut b.key, key);
+        copy_memory(key, &mut b.key);
         b
     }
 
@@ -184,7 +184,7 @@ impl Blake2b {
 
     fn apply_key(&mut self) {
         let mut block : [u8; BLAKE2B_BLOCKBYTES] = [0; BLAKE2B_BLOCKBYTES];
-        copy_memory(&mut block, &self.key[..self.key_length as usize]);
+        copy_memory(&self.key[..self.key_length as usize], &mut block);
         self.update(&block);
         unsafe {
             volatile_set_memory(block.as_mut_ptr(), 0, block.len());
@@ -256,20 +256,20 @@ impl Blake2b {
             let fill = 2 * BLAKE2B_BLOCKBYTES - left;
 
             if input.len() > fill {
-                copy_memory( &mut self.buf[left..], &input[0..fill] ); // Fill buffer
+                copy_memory(&input[0..fill], &mut self.buf[left..]); // Fill buffer
                 self.buflen += fill;
                 self.increment_counter( BLAKE2B_BLOCKBYTES as u64);
                 self.compress();
 
                 let mut halves = self.buf.chunks_mut(BLAKE2B_BLOCKBYTES);
                 let first_half = halves.next().unwrap();
                 let second_half = halves.next().unwrap();
-                copy_memory(first_half, second_half);
+                copy_memory(second_half, first_half);
 
                 self.buflen -= BLAKE2B_BLOCKBYTES;
                 input = &input[fill..input.len()];
             } else { // inlen <= fill
-                copy_memory(&mut self.buf[left..], input);
+                copy_memory(input, &mut self.buf[left..]);
                 self.buflen += input.len();
                 break;
             }
@@ -287,7 +287,7 @@ impl Blake2b {
                 let mut halves = self.buf.chunks_mut(BLAKE2B_BLOCKBYTES);
                 let first_half = halves.next().unwrap();
                 let second_half = halves.next().unwrap();
-                copy_memory(first_half, second_half);
+                copy_memory(second_half, first_half);
             }
 
             let incby = self.buflen as u64;
@@ -304,7 +304,7 @@ impl Blake2b {
             self.computed = true;
         }
         let outlen = out.len();
-        copy_memory(out, &self.buf[0..outlen]);
+        copy_memory(&self.buf[0..outlen], out);
     }
 
     pub fn blake2b(out: &mut[u8], input: &[u8], key: &[u8]) {
diff --git a/src/blockmodes.rs b/src/blockmodes.rs
@@ -94,14 +94,14 @@ fn update_history(in_hist: &mut [u8], out_hist: &mut [u8], last_in: &[u8], last_
     let in_hist_len = in_hist.len();
     if in_hist_len > 0 {
         slice::bytes::copy_memory(
-            in_hist,
-            &last_in[last_in.len() - in_hist_len..]);
+            &last_in[last_in.len() - in_hist_len..],
+            in_hist);
     }
     let out_hist_len = out_hist.len();
     if out_hist_len > 0 {
         slice::bytes::copy_memory(
-            out_hist,
-            &last_out[last_out.len() - out_hist_len..]);
+            &last_out[last_out.len() - out_hist_len..],
+            out_hist);
     }
 }
 
@@ -412,8 +412,8 @@ impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {
     }
     fn reset_with_history(&mut self, in_hist: &[u8], out_hist: &[u8]) {
         self.reset();
-        slice::bytes::copy_memory(&mut self.in_hist, in_hist);
-        slice::bytes::copy_memory(&mut self.out_hist, out_hist);
+        slice::bytes::copy_memory(in_hist, &mut self.in_hist);
+        slice::bytes::copy_memory(out_hist, &mut self.out_hist);
     }
 }
 
@@ -690,7 +690,7 @@ impl <A: BlockEncryptor> CtrMode<A> {
         }
     }
     pub fn reset(&mut self, ctr: &[u8]) {
-        slice::bytes::copy_memory(&mut self.ctr, ctr);
+        slice::bytes::copy_memory(ctr, &mut self.ctr);
         self.bytes.reset();
     }
     fn process(&mut self, input: &[u8], output: &mut [u8]) {
@@ -744,7 +744,7 @@ pub struct CtrModeX8<A> {
 
 fn construct_ctr_x8(in_ctr: &[u8], out_ctr_x8: &mut [u8]) {
     for (i, ctr_i) in out_ctr_x8.chunks_mut(in_ctr.len()).enumerate() {
-        slice::bytes::copy_memory(ctr_i, in_ctr);
+        slice::bytes::copy_memory(in_ctr, ctr_i);
         add_ctr(ctr_i, i as u8);
     }
 }
diff --git a/src/buffer.rs b/src/buffer.rs
@@ -37,7 +37,7 @@ pub trait ReadBuffer {
 
     fn push_to<W: WriteBuffer>(&mut self, output: &mut W) {
         let count = cmp::min(output.remaining(), self.remaining());
-        slice::bytes::copy_memory(output.take_next(count), self.take_next(count));
+        slice::bytes::copy_memory(self.take_next(count), output.take_next(count));
     }
 }
 
diff --git a/src/cryptoutil.rs b/src/cryptoutil.rs
@@ -25,7 +25,7 @@ pub fn write_u64_be(dst: &mut[u8], mut input: u64) {
     input = input.to_be();
     unsafe {
         let tmp = &input as *const _ as *const u8;
-        ptr::copy_nonoverlapping(dst.get_unchecked_mut(0), tmp, 8);
+        ptr::copy_nonoverlapping(tmp, dst.get_unchecked_mut(0), 8);
     }
 }
 
@@ -36,7 +36,7 @@ pub fn write_u64_le(dst: &mut[u8], mut input: u64) {
     input = input.to_le();
     unsafe {
         let tmp = &input as *const _ as *const u8;
-        ptr::copy_nonoverlapping(dst.get_unchecked_mut(0), tmp, 8);
+        ptr::copy_nonoverlapping(tmp, dst.get_unchecked_mut(0), 8);
     }
 }
 
@@ -48,7 +48,7 @@ pub fn write_u64v_le(dst: &mut[u8], input: &[u64]) {
         let mut y: *const u64 = input.get_unchecked(0);
         for _ in (0..input.len()) {
             let tmp = (*y).to_le();
-            ptr::copy_nonoverlapping(x, &tmp as *const _ as *const u8, 8);
+            ptr::copy_nonoverlapping(&tmp as *const _ as *const u8, x, 8);
             x = x.offset(8);
             y = y.offset(1);
         }
@@ -62,7 +62,7 @@ pub fn write_u32_be(dst: &mut [u8], mut input: u32) {
     input = input.to_be();
     unsafe {
         let tmp = &input as *const _ as *const u8;
-        ptr::copy_nonoverlapping(dst.get_unchecked_mut(0), tmp, 4);
+        ptr::copy_nonoverlapping(tmp, dst.get_unchecked_mut(0), 4);
     }
 }
 
@@ -73,7 +73,7 @@ pub fn write_u32_le(dst: &mut[u8], mut input: u32) {
     input = input.to_le();
     unsafe {
         let tmp = &input as *const _ as *const u8;
-        ptr::copy_nonoverlapping(dst.get_unchecked_mut(0), tmp, 4);
+        ptr::copy_nonoverlapping(tmp, dst.get_unchecked_mut(0), 4);
     }
 }
 
@@ -85,7 +85,7 @@ pub fn write_u32v_le (dst: &mut[u8], input: &[u32]) {
         let mut y: *const u32 = input.get_unchecked(0);
         for _ in 0..input.len() {
             let tmp = (*y).to_le();
-            ptr::copy_nonoverlapping(x, &tmp as *const _ as *const u8, 4);
+            ptr::copy_nonoverlapping(&tmp as *const _ as *const u8, x, 4);
             x = x.offset(4);
             y = y.offset(1);
         }
@@ -100,7 +100,7 @@ pub fn read_u64v_be(dst: &mut[u64], input: &[u8]) {
         let mut y: *const u8 = input.get_unchecked(0);
         for _ in (0..dst.len()) {
             let mut tmp: u64 = mem::uninitialized();
-            ptr::copy_nonoverlapping(&mut tmp as *mut _ as *mut u8, y, 8);
+            ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 8);
             *x = Int::from_be(tmp);
             x = x.offset(1);
             y = y.offset(8);
@@ -116,7 +116,7 @@ pub fn read_u64v_le(dst: &mut[u64], input: &[u8]) {
         let mut y: *const u8 = input.get_unchecked(0);
         for _ in (0..dst.len()) {
             let mut tmp: u64 = mem::uninitialized();
-            ptr::copy_nonoverlapping(&mut tmp as *mut _ as *mut u8, y, 8);
+            ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 8);
             *x = Int::from_le(tmp);
             x = x.offset(1);
             y = y.offset(8);
@@ -132,7 +132,7 @@ pub fn read_u32v_be(dst: &mut[u32], input: &[u8]) {
         let mut y: *const u8 = input.get_unchecked(0);
         for _ in (0..dst.len()) {
             let mut tmp: u32 = mem::uninitialized();
-            ptr::copy_nonoverlapping(&mut tmp as *mut _ as *mut u8, y, 4);
+            ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 4);
             *x = Int::from_be(tmp);
             x = x.offset(1);
             y = y.offset(4);
@@ -148,7 +148,7 @@ pub fn read_u32v_le(dst: &mut[u32], input: &[u8]) {
         let mut y: *const u8 = input.get_unchecked(0);
         for _ in (0..dst.len()) {
             let mut tmp: u32 = mem::uninitialized();
-            ptr::copy_nonoverlapping(&mut tmp as *mut _ as *mut u8, y, 4);
+            ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 4);
             *x = Int::from_le(tmp);
             x = x.offset(1);
             y = y.offset(4);
@@ -161,7 +161,7 @@ pub fn read_u32_le(input: &[u8]) -> u32 {
     assert!(input.len() == 4);
     unsafe {
         let mut tmp: u32 = mem::uninitialized();
-        ptr::copy_nonoverlapping(&mut tmp as *mut _ as *mut u8, input.get_unchecked(0), 4);
+        ptr::copy_nonoverlapping(input.get_unchecked(0), &mut tmp as *mut _ as *mut u8, 4);
         Int::from_le(tmp)
     }
 }
@@ -171,7 +171,7 @@ pub fn read_u32_be(input: &[u8]) -> u32 {
     assert!(input.len() == 4);
     unsafe {
         let mut tmp: u32 = mem::uninitialized();
-        ptr::copy_nonoverlapping(&mut tmp as *mut _ as *mut u8, input.get_unchecked(0), 4);
+        ptr::copy_nonoverlapping(input.get_unchecked(0), &mut tmp as *mut _ as *mut u8, 4);
         Int::from_be(tmp)
     }
 }
@@ -364,15 +364,15 @@ macro_rules! impl_fixed_buffer( ($name:ident, $size:expr) => (
                 let buffer_remaining = size - self.buffer_idx;
                 if input.len() >= buffer_remaining {
                         copy_memory(
-                            &mut self.buffer[self.buffer_idx..size],
-                            &input[..buffer_remaining]);
+                            &input[..buffer_remaining],
+                            &mut self.buffer[self.buffer_idx..size]);
                     self.buffer_idx = 0;
                     func(&self.buffer);
                     i += buffer_remaining;
                 } else {
                     copy_memory(
-                        &mut self.buffer[self.buffer_idx..self.buffer_idx + input.len()],
-                        input);
+                        input,
+                        &mut self.buffer[self.buffer_idx..self.buffer_idx + input.len()]);
                     self.buffer_idx += input.len();
                     return;
                 }
@@ -390,8 +390,8 @@ macro_rules! impl_fixed_buffer( ($name:ident, $size:expr) => (
             // be empty.
             let input_remaining = input.len() - i;
             copy_memory(
-                &mut self.buffer[0..input_remaining],
-                &input[i..]);
+                &input[i..],
+                &mut self.buffer[0..input_remaining]);
             self.buffer_idx += input_remaining;
         }
 
diff --git a/src/fortuna.rs b/src/fortuna.rs
@@ -135,7 +135,7 @@ impl FortunaGenerator {
         if rem > 0 {
             let mut buf = [0; AES_BLOCK_SIZE];
             self.generate_blocks(1, &mut buf);
-            copy_memory(&mut out[(n * AES_BLOCK_SIZE)..], &buf[..rem]);
+            copy_memory(&buf[..rem], &mut out[(n * AES_BLOCK_SIZE)..]);
         }
 
         // Rekey
diff --git a/src/ghash.rs b/src/ghash.rs
@@ -161,13 +161,13 @@ fn update(state: &mut Gf128, len: &mut usize, data: &[u8], srest: &mut Option<[u
         None => data,
         Some(mut rest) => {
             if 16 - rest_len > data_len {
-                copy_memory(&mut rest[rest_len..], data);
+                copy_memory(data, &mut rest[rest_len..]);
                 *srest = Some(rest);
                 return;
             }
 
             let (fill, data) = data.split_at(16 - rest_len);
-            copy_memory(&mut rest[rest_len..], fill);
+            copy_memory(fill, &mut rest[rest_len..]);
             state.add_and_mul(Gf128::from_bytes(&rest), hs);
             data
         }
@@ -182,7 +182,7 @@ fn update(state: &mut Gf128, len: &mut usize, data: &[u8], srest: &mut Option<[u
 
     if rest.len() != 0 {
         let mut tmp = [0; 16];
-        copy_memory(&mut tmp, rest);
+        copy_memory(rest, &mut tmp);
         *srest = Some(tmp);
     }
 }
@@ -316,7 +316,7 @@ impl Mac for Ghash {
             self.finished = true;
         }
 
-        copy_memory(output, &self.state.to_bytes());
+        copy_memory(&self.state.to_bytes(), output);
     }
 
     fn output_bytes(&self) -> usize { 16 }
diff --git a/src/hc128.rs b/src/hc128.rs
@@ -41,14 +41,14 @@ impl Hc128 {
             w[i >> 2] |= (key[i] as u32) << (8 * (i & 0x3));
         }
         unsafe {
-            ptr::copy_nonoverlapping(w.as_mut_ptr().offset(4), w.as_ptr(), 4);
+            ptr::copy_nonoverlapping(w.as_ptr(), w.as_mut_ptr().offset(4), 4);
         }
 
         for i in (0..nonce.len() & 16) {
             w[(i >> 2) + 8] |= (nonce[i] as u32) << (8 * (i & 0x3));
         }
         unsafe {
-            ptr::copy_nonoverlapping(w.as_mut_ptr().offset(12), w.as_ptr().offset(8), 4);
+            ptr::copy_nonoverlapping(w.as_ptr().offset(8), w.as_mut_ptr().offset(12), 4);
         }
 
         for i in 16..1280 {
@@ -57,8 +57,8 @@ impl Hc128 {
 
         // Copy contents of w into p and q
         unsafe {
-            ptr::copy_nonoverlapping(self.p.as_mut_ptr(), w.as_ptr().offset(256), 512);
-            ptr::copy_nonoverlapping(self.q.as_mut_ptr(), w.as_ptr().offset(768), 512);
+            ptr::copy_nonoverlapping(w.as_ptr().offset(256), self.p.as_mut_ptr(),  512);
+            ptr::copy_nonoverlapping(w.as_ptr().offset(768), self.q.as_mut_ptr(), 512);
         }
         
         for i in 0..512 {
diff --git a/src/hkdf.rs b/src/hkdf.rs
@@ -63,7 +63,7 @@ pub fn hkdf_expand<D: Digest>(mut digest: D, prk: &[u8], info: &[u8], okm: &mut
         mac.raw_result(&mut t);
         mac.reset();
         let chunk_len = chunk.len();
-        copy_memory(chunk, &t[..chunk_len]);
+        copy_memory(&t[..chunk_len], chunk);
     }
 }
 
diff --git a/src/hmac.rs b/src/hmac.rs
@@ -38,7 +38,7 @@ fn expand_key<D: Digest>(digest: &mut D, key: &[u8]) -> Vec<u8> {
     let mut expanded_key: Vec<u8> = repeat(0).take(bs).collect();
 
     if key.len() <= bs {
-        slice::bytes::copy_memory(&mut expanded_key, key);
+        slice::bytes::copy_memory(key, &mut expanded_key);
     } else {
         let output_size = digest.output_bytes();
         digest.input(key);
diff --git a/src/pbkdf2.rs b/src/pbkdf2.rs
@@ -105,7 +105,7 @@ pub fn pbkdf2<M: Mac>(mac: &mut M, salt: &[u8], c: u32, output: &mut [u8]) {
             let mut tmp: Vec<u8> = repeat(0).take(os).collect();
             calculate_block(mac, salt, c, idx, &mut scratch[..], &mut tmp[..]);
             let chunk_len = chunk.len();
-            copy_memory(chunk, &tmp[..chunk_len]);
+            copy_memory(&tmp[..chunk_len], chunk);
         }
     }
 }
diff --git a/src/scrypt.rs b/src/scrypt.rs
@@ -97,15 +97,15 @@ fn xor(x: &[u8], y: &[u8], output: &mut [u8]) {
 // output - the output vector. Must be the same length as input.
 fn scrypt_block_mix(input: &[u8], output: &mut [u8]) {
     let mut x = [0u8; 64];
-    copy_memory(&mut x, &input[input.len() - 64..]);
+    copy_memory(&input[input.len() - 64..], &mut x);
 
     let mut t = [0u8; 64];
 
     for (i, chunk) in input.chunks(64).enumerate() {
         xor(&x, chunk, &mut t);
         salsa20_8(&t, &mut x);
         let pos = if i % 2 == 0 { (i / 2) * 64 } else { (i / 2) * 64 + input.len() / 2 };
-        copy_memory(&mut output[pos..pos + 64], &x);
+        copy_memory(&x, &mut output[pos..pos + 64]);
     }
 }
 
@@ -128,7 +128,7 @@ fn scrypt_ro_mix(b: &mut [u8], v: &mut [u8], t: &mut [u8], n: usize) {
     let len = b.len();
 
     for chunk in v.chunks_mut(len) {
-        copy_memory(chunk, b);
+        copy_memory(b, chunk);
         scrypt_block_mix(chunk, b);
     }
 
diff --git a/src/sosemanuk.rs b/src/sosemanuk.rs

Original file line number	Diff line number	Diff line change
`@@ -94,14 +94,14 @@ fn update_history(in_hist: &mut [u8], out_hist: &mut [u8], last_in: &[u8], last_`
`94`	`94`	`let in_hist_len = in_hist.len();`
`95`	`95`	`if in_hist_len > 0 {`
`96`	`96`	`slice::bytes::copy_memory(`
`97`		`- in_hist,`
`98`		`- &last_in[last_in.len() - in_hist_len..]);`
	`97`	`+ &last_in[last_in.len() - in_hist_len..],`
	`98`	`+ in_hist);`
`99`	`99`	`}`
`100`	`100`	`let out_hist_len = out_hist.len();`
`101`	`101`	`if out_hist_len > 0 {`
`102`	`102`	`slice::bytes::copy_memory(`
`103`		`- out_hist,`
`104`		`- &last_out[last_out.len() - out_hist_len..]);`
	`103`	`+ &last_out[last_out.len() - out_hist_len..],`
	`104`	`+ out_hist);`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`@@ -412,8 +412,8 @@ impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {`
`412`	`412`	`}`
`413`	`413`	`fn reset_with_history(&mut self, in_hist: &[u8], out_hist: &[u8]) {`
`414`	`414`	`self.reset();`
`415`		`- slice::bytes::copy_memory(&mut self.in_hist, in_hist);`
`416`		`- slice::bytes::copy_memory(&mut self.out_hist, out_hist);`
	`415`	`+ slice::bytes::copy_memory(in_hist, &mut self.in_hist);`
	`416`	`+ slice::bytes::copy_memory(out_hist, &mut self.out_hist);`
`417`	`417`	`}`
`418`	`418`	`}`
`419`	`419`
`@@ -690,7 +690,7 @@ impl <A: BlockEncryptor> CtrMode<A> {`
`690`	`690`	`}`
`691`	`691`	`}`
`692`	`692`	`pub fn reset(&mut self, ctr: &[u8]) {`
`693`		`- slice::bytes::copy_memory(&mut self.ctr, ctr);`
	`693`	`+ slice::bytes::copy_memory(ctr, &mut self.ctr);`
`694`	`694`	`self.bytes.reset();`
`695`	`695`	`}`
`696`	`696`	`fn process(&mut self, input: &[u8], output: &mut [u8]) {`
`@@ -744,7 +744,7 @@ pub struct CtrModeX8<A> {`
`744`	`744`
`745`	`745`	`fn construct_ctr_x8(in_ctr: &[u8], out_ctr_x8: &mut [u8]) {`
`746`	`746`	`for (i, ctr_i) in out_ctr_x8.chunks_mut(in_ctr.len()).enumerate() {`
`747`		`- slice::bytes::copy_memory(ctr_i, in_ctr);`
	`747`	`+ slice::bytes::copy_memory(in_ctr, ctr_i);`
`748`	`748`	`add_ctr(ctr_i, i as u8);`
`749`	`749`	`}`
`750`	`750`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ pub trait ReadBuffer {`
`37`	`37`
`38`	`38`	`fn push_to<W: WriteBuffer>(&mut self, output: &mut W) {`
`39`	`39`	`let count = cmp::min(output.remaining(), self.remaining());`
`40`		`- slice::bytes::copy_memory(output.take_next(count), self.take_next(count));`
	`40`	`+ slice::bytes::copy_memory(self.take_next(count), output.take_next(count));`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ impl FortunaGenerator {`
`135`	`135`	`if rem > 0 {`
`136`	`136`	`let mut buf = [0; AES_BLOCK_SIZE];`
`137`	`137`	`self.generate_blocks(1, &mut buf);`
`138`		`- copy_memory(&mut out[(n * AES_BLOCK_SIZE)..], &buf[..rem]);`
	`138`	`+ copy_memory(&buf[..rem], &mut out[(n * AES_BLOCK_SIZE)..]);`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`// Rekey`
Original file line number	Diff line number	Diff line change
`@@ -161,13 +161,13 @@ fn update(state: &mut Gf128, len: &mut usize, data: &[u8], srest: &mut Option<[u`
`161`	`161`	`None => data,`
`162`	`162`	`Some(mut rest) => {`
`163`	`163`	`if 16 - rest_len > data_len {`
`164`		`- copy_memory(&mut rest[rest_len..], data);`
	`164`	`+ copy_memory(data, &mut rest[rest_len..]);`
`165`	`165`	`*srest = Some(rest);`
`166`	`166`	`return;`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`let (fill, data) = data.split_at(16 - rest_len);`
`170`		`- copy_memory(&mut rest[rest_len..], fill);`
	`170`	`+ copy_memory(fill, &mut rest[rest_len..]);`
`171`	`171`	`state.add_and_mul(Gf128::from_bytes(&rest), hs);`
`172`	`172`	`data`
`173`	`173`	`}`
`@@ -182,7 +182,7 @@ fn update(state: &mut Gf128, len: &mut usize, data: &[u8], srest: &mut Option<[u`
`182`	`182`
`183`	`183`	`if rest.len() != 0 {`
`184`	`184`	`let mut tmp = [0; 16];`
`185`		`- copy_memory(&mut tmp, rest);`
	`185`	`+ copy_memory(rest, &mut tmp);`
`186`	`186`	`*srest = Some(tmp);`
`187`	`187`	`}`
`188`	`188`	`}`
`@@ -316,7 +316,7 @@ impl Mac for Ghash {`
`316`	`316`	`self.finished = true;`
`317`	`317`	`}`
`318`	`318`
`319`		`- copy_memory(output, &self.state.to_bytes());`
	`319`	`+ copy_memory(&self.state.to_bytes(), output);`
`320`	`320`	`}`
`321`	`321`
`322`	`322`	`fn output_bytes(&self) -> usize { 16 }`
Original file line number	Diff line number	Diff line change
`@@ -41,14 +41,14 @@ impl Hc128 {`
`41`	`41`	`w[i >> 2] \|= (key[i] as u32) << (8 * (i & 0x3));`
`42`	`42`	`}`
`43`	`43`	`unsafe {`
`44`		`- ptr::copy_nonoverlapping(w.as_mut_ptr().offset(4), w.as_ptr(), 4);`
	`44`	`+ ptr::copy_nonoverlapping(w.as_ptr(), w.as_mut_ptr().offset(4), 4);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`for i in (0..nonce.len() & 16) {`
`48`	`48`	`w[(i >> 2) + 8] \|= (nonce[i] as u32) << (8 * (i & 0x3));`
`49`	`49`	`}`
`50`	`50`	`unsafe {`
`51`		`- ptr::copy_nonoverlapping(w.as_mut_ptr().offset(12), w.as_ptr().offset(8), 4);`
	`51`	`+ ptr::copy_nonoverlapping(w.as_ptr().offset(8), w.as_mut_ptr().offset(12), 4);`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`for i in 16..1280 {`
`@@ -57,8 +57,8 @@ impl Hc128 {`
`57`	`57`
`58`	`58`	`// Copy contents of w into p and q`
`59`	`59`	`unsafe {`
`60`		`- ptr::copy_nonoverlapping(self.p.as_mut_ptr(), w.as_ptr().offset(256), 512);`
`61`		`- ptr::copy_nonoverlapping(self.q.as_mut_ptr(), w.as_ptr().offset(768), 512);`
	`60`	`+ ptr::copy_nonoverlapping(w.as_ptr().offset(256), self.p.as_mut_ptr(), 512);`
	`61`	`+ ptr::copy_nonoverlapping(w.as_ptr().offset(768), self.q.as_mut_ptr(), 512);`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`for i in 0..512 {`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ pub fn hkdf_expand<D: Digest>(mut digest: D, prk: &[u8], info: &[u8], okm: &mut`
`63`	`63`	`mac.raw_result(&mut t);`
`64`	`64`	`mac.reset();`
`65`	`65`	`let chunk_len = chunk.len();`
`66`		`- copy_memory(chunk, &t[..chunk_len]);`
	`66`	`+ copy_memory(&t[..chunk_len], chunk);`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ pub fn pbkdf2<M: Mac>(mac: &mut M, salt: &[u8], c: u32, output: &mut [u8]) {`
`105`	`105`	`let mut tmp: Vec<u8> = repeat(0).take(os).collect();`
`106`	`106`	`calculate_block(mac, salt, c, idx, &mut scratch[..], &mut tmp[..]);`
`107`	`107`	`let chunk_len = chunk.len();`
`108`		`- copy_memory(chunk, &tmp[..chunk_len]);`
	`108`	`+ copy_memory(&tmp[..chunk_len], chunk);`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`	`}`