Skip to content

Commit e767b7d

Browse files
sunfishcodesunfishcode
committed
More.
1 parent 4a42814 commit e767b7d

1 file changed

Lines changed: 104 additions & 88 deletions

File tree

‎src/mem/impls.rs‎

Lines changed: 104 additions & 88 deletions
Original file line numberDiff line numberDiff line change
@@ -40,24 +40,28 @@ pub unsafe fn copy_forward(mut dest: *mut u8, mut src: *const u8, mut n: usize)
4040
unsafe {
4141
#[inline(always)]
4242
unsafe fn copy_forward_bytes(mut dest: *mut u8, mut src: *const u8, n: usize) {
43-
let dest_end = dest.add(n);
44-
while dest < dest_end {
45-
*dest = *src;
46-
dest = dest.add(1);
47-
src = src.add(1);
43+
unsafe {
44+
let dest_end = dest.add(n);
45+
while dest < dest_end {
46+
*dest = *src;
47+
dest = dest.add(1);
48+
src = src.add(1);
49+
}
4850
}
4951
}
5052

5153
#[inline(always)]
5254
unsafe fn copy_forward_aligned_words(dest: *mut u8, src: *const u8, n: usize) {
53-
let mut dest_usize = dest as *mut usize;
54-
let mut src_usize = src as *mut usize;
55-
let dest_end = dest.add(n) as *mut usize;
56-
57-
while dest_usize < dest_end {
58-
*dest_usize = *src_usize;
59-
dest_usize = dest_usize.add(1);
60-
src_usize = src_usize.add(1);
55+
unsafe {
56+
let mut dest_usize = dest as *mut usize;
57+
let mut src_usize = src as *mut usize;
58+
let dest_end = dest.add(n) as *mut usize;
59+
60+
while dest_usize < dest_end {
61+
*dest_usize = *src_usize;
62+
dest_usize = dest_usize.add(1);
63+
src_usize = src_usize.add(1);
64+
}
6165
}
6266
}
6367

@@ -69,29 +73,31 @@ pub unsafe fn copy_forward(mut dest: *mut u8, mut src: *const u8, mut n: usize)
6973
)))]
7074
#[inline(always)]
7175
unsafe fn copy_forward_misaligned_words(dest: *mut u8, src: *const u8, n: usize) {
72-
let mut dest_usize = dest as *mut usize;
73-
let dest_end = dest.add(n) as *mut usize;
74-
75-
// Calculate the misalignment offset and shift needed to reassemble value.
76-
let offset = src.addr() & WORD_MASK;
77-
let shift = offset * 8;
78-
79-
// Realign src
80-
let mut src_aligned = src.with_addr(src.addr() & !WORD_MASK).cast::<usize>();
81-
// This will read (but won't use) bytes out of bound.
82-
let mut prev_word = crate::arch::oob_load(src_aligned);
83-
84-
while dest_usize < dest_end {
85-
src_aligned = src_aligned.add(1);
86-
let cur_word = *src_aligned;
87-
#[cfg(target_endian = "little")]
88-
let resembled = prev_word >> shift | cur_word << (WORD_SIZE * 8 - shift);
89-
#[cfg(target_endian = "big")]
90-
let resembled = prev_word << shift | cur_word >> (WORD_SIZE * 8 - shift);
91-
prev_word = cur_word;
92-
93-
*dest_usize = resembled;
94-
dest_usize = dest_usize.add(1);
76+
unsafe {
77+
let mut dest_usize = dest as *mut usize;
78+
let dest_end = dest.add(n) as *mut usize;
79+
80+
// Calculate the misalignment offset and shift needed to reassemble value.
81+
let offset = src.addr() & WORD_MASK;
82+
let shift = offset * 8;
83+
84+
// Realign src
85+
let mut src_aligned = src.with_addr(src.addr() & !WORD_MASK).cast::<usize>();
86+
// This will read (but won't use) bytes out of bound.
87+
let mut prev_word = crate::arch::oob_load(src_aligned);
88+
89+
while dest_usize < dest_end {
90+
src_aligned = src_aligned.add(1);
91+
let cur_word = *src_aligned;
92+
#[cfg(target_endian = "little")]
93+
let resembled = prev_word >> shift | cur_word << (WORD_SIZE * 8 - shift);
94+
#[cfg(target_endian = "big")]
95+
let resembled = prev_word << shift | cur_word >> (WORD_SIZE * 8 - shift);
96+
prev_word = cur_word;
97+
98+
*dest_usize = resembled;
99+
dest_usize = dest_usize.add(1);
100+
}
95101
}
96102
}
97103

@@ -103,14 +109,16 @@ pub unsafe fn copy_forward(mut dest: *mut u8, mut src: *const u8, mut n: usize)
103109
))]
104110
#[inline(always)]
105111
unsafe fn copy_forward_misaligned_words(dest: *mut u8, src: *const u8, n: usize) {
106-
let mut dest_usize = dest as *mut usize;
107-
let mut src_usize = src as *mut usize;
108-
let dest_end = dest.add(n) as *mut usize;
109-
110-
while dest_usize < dest_end {
111-
*dest_usize = read_usize_unaligned(src_usize);
112-
dest_usize = dest_usize.add(1);
113-
src_usize = src_usize.add(1);
112+
unsafe {
113+
let mut dest_usize = dest as *mut usize;
114+
let mut src_usize = src as *mut usize;
115+
let dest_end = dest.add(n) as *mut usize;
116+
117+
while dest_usize < dest_end {
118+
*dest_usize = read_usize_unaligned(src_usize);
119+
dest_usize = dest_usize.add(1);
120+
src_usize = src_usize.add(1);
121+
}
114122
}
115123
}
116124

@@ -145,24 +153,28 @@ pub unsafe fn copy_backward(dest: *mut u8, src: *const u8, mut n: usize) {
145153
// as their inputs instead of pointers to the start!
146154
#[inline(always)]
147155
unsafe fn copy_backward_bytes(mut dest: *mut u8, mut src: *const u8, n: usize) {
148-
let dest_start = dest.sub(n);
149-
while dest_start < dest {
150-
dest = dest.sub(1);
151-
src = src.sub(1);
152-
*dest = *src;
156+
unsafe {
157+
let dest_start = dest.sub(n);
158+
while dest_start < dest {
159+
dest = dest.sub(1);
160+
src = src.sub(1);
161+
*dest = *src;
162+
}
153163
}
154164
}
155165

156166
#[inline(always)]
157167
unsafe fn copy_backward_aligned_words(dest: *mut u8, src: *const u8, n: usize) {
158-
let mut dest_usize = dest as *mut usize;
159-
let mut src_usize = src as *mut usize;
160-
let dest_start = dest.sub(n) as *mut usize;
161-
162-
while dest_start < dest_usize {
163-
dest_usize = dest_usize.sub(1);
164-
src_usize = src_usize.sub(1);
165-
*dest_usize = *src_usize;
168+
unsafe {
169+
let mut dest_usize = dest as *mut usize;
170+
let mut src_usize = src as *mut usize;
171+
let dest_start = dest.sub(n) as *mut usize;
172+
173+
while dest_start < dest_usize {
174+
dest_usize = dest_usize.sub(1);
175+
src_usize = src_usize.sub(1);
176+
*dest_usize = *src_usize;
177+
}
166178
}
167179
}
168180

@@ -174,29 +186,31 @@ pub unsafe fn copy_backward(dest: *mut u8, src: *const u8, mut n: usize) {
174186
)))]
175187
#[inline(always)]
176188
unsafe fn copy_backward_misaligned_words(dest: *mut u8, src: *const u8, n: usize) {
177-
let mut dest_usize = dest as *mut usize;
178-
let dest_start = dest.sub(n) as *mut usize;
179-
180-
// Calculate the misalignment offset and shift needed to reassemble value.
181-
let offset = src.addr() & WORD_MASK;
182-
let shift = offset * 8;
183-
184-
// Realign src_aligned
185-
let mut src_aligned = src.with_addr(src.addr() & !WORD_MASK).cast::<usize>();
186-
// This will read (but won't use) bytes out of bound.
187-
let mut prev_word = crate::arch::oob_load(src_aligned);
188-
189-
while dest_start < dest_usize {
190-
src_aligned = src_aligned.sub(1);
191-
let cur_word = *src_aligned;
192-
#[cfg(target_endian = "little")]
193-
let resembled = prev_word << (WORD_SIZE * 8 - shift) | cur_word >> shift;
194-
#[cfg(target_endian = "big")]
195-
let resembled = prev_word >> (WORD_SIZE * 8 - shift) | cur_word << shift;
196-
prev_word = cur_word;
197-
198-
dest_usize = dest_usize.sub(1);
199-
*dest_usize = resembled;
189+
unsafe {
190+
let mut dest_usize = dest as *mut usize;
191+
let dest_start = dest.sub(n) as *mut usize;
192+
193+
// Calculate the misalignment offset and shift needed to reassemble value.
194+
let offset = src.addr() & WORD_MASK;
195+
let shift = offset * 8;
196+
197+
// Realign src_aligned
198+
let mut src_aligned = src.with_addr(src.addr() & !WORD_MASK).cast::<usize>();
199+
// This will read (but won't use) bytes out of bound.
200+
let mut prev_word = crate::arch::oob_load(src_aligned);
201+
202+
while dest_start < dest_usize {
203+
src_aligned = src_aligned.sub(1);
204+
let cur_word = *src_aligned;
205+
#[cfg(target_endian = "little")]
206+
let resembled = prev_word << (WORD_SIZE * 8 - shift) | cur_word >> shift;
207+
#[cfg(target_endian = "big")]
208+
let resembled = prev_word >> (WORD_SIZE * 8 - shift) | cur_word << shift;
209+
prev_word = cur_word;
210+
211+
dest_usize = dest_usize.sub(1);
212+
*dest_usize = resembled;
213+
}
200214
}
201215
}
202216

@@ -208,14 +222,16 @@ pub unsafe fn copy_backward(dest: *mut u8, src: *const u8, mut n: usize) {
208222
))]
209223
#[inline(always)]
210224
unsafe fn copy_backward_misaligned_words(dest: *mut u8, src: *const u8, n: usize) {
211-
let mut dest_usize = dest as *mut usize;
212-
let mut src_usize = src as *mut usize;
213-
let dest_start = dest.sub(n) as *mut usize;
214-
215-
while dest_start < dest_usize {
216-
dest_usize = dest_usize.sub(1);
217-
src_usize = src_usize.sub(1);
218-
*dest_usize = read_usize_unaligned(src_usize);
225+
unsafe {
226+
let mut dest_usize = dest as *mut usize;
227+
let mut src_usize = src as *mut usize;
228+
let dest_start = dest.sub(n) as *mut usize;
229+
230+
while dest_start < dest_usize {
231+
dest_usize = dest_usize.sub(1);
232+
src_usize = src_usize.sub(1);
233+
*dest_usize = read_usize_unaligned(src_usize);
234+
}
219235
}
220236
}
221237

0 commit comments

Comments
 (0)