54 }
55
56 class CopySwap : AllStatic {
57 public:
58 /**
59 * Copy and optionally byte swap elements
60 *
61 * <swap> - true if elements should be byte swapped
62 *
63 * @param src address of source
64 * @param dst address of destination
65 * @param byte_count number of bytes to copy
66 * @param elem_size size of the elements to copy-swap
67 */
68 template<bool swap>
69 static void conjoint_swap_if_needed(const void* src, void* dst, size_t byte_count, size_t elem_size) {
70 assert(src != NULL, "address must not be NULL");
71 assert(dst != NULL, "address must not be NULL");
72 assert(elem_size == 2 || elem_size == 4 || elem_size == 8,
73 "incorrect element size: " SIZE_FORMAT, elem_size);
74 assert(is_size_aligned(byte_count, elem_size),
75 "byte_count " SIZE_FORMAT " must be multiple of element size " SIZE_FORMAT, byte_count, elem_size);
76
77 address src_end = (address)src + byte_count;
78
79 if (dst <= src || dst >= src_end) {
80 do_conjoint_swap<RIGHT,swap>(src, dst, byte_count, elem_size);
81 } else {
82 do_conjoint_swap<LEFT,swap>(src, dst, byte_count, elem_size);
83 }
84 }
85
86 private:
87 /**
88 * Byte swap a 16-bit value
89 */
90 static uint16_t byte_swap(uint16_t x) {
91 return (x << 8) | (x >> 8);
92 }
93
94 /**
172 cur_src -= sizeof(T);
173 cur_dst -= sizeof(T);
174 break;
175 }
176 }
177 }
178
179 /**
180 * Copy and byte swap elements
181 *
182 * <T> - type of element to copy
183 * <D> - copy direction
184 * <swap> - true if elements should be byte swapped
185 *
186 * @param src address of source
187 * @param dst address of destination
188 * @param byte_count number of bytes to copy
189 */
190 template <typename T, CopyDirection direction, bool swap>
191 static void do_conjoint_swap(const void* src, void* dst, size_t byte_count) {
192 if (is_ptr_aligned(src, sizeof(T))) {
193 if (is_ptr_aligned(dst, sizeof(T))) {
194 do_conjoint_swap<T,direction,swap,true,true>(src, dst, byte_count);
195 } else {
196 do_conjoint_swap<T,direction,swap,true,false>(src, dst, byte_count);
197 }
198 } else {
199 if (is_ptr_aligned(dst, sizeof(T))) {
200 do_conjoint_swap<T,direction,swap,false,true>(src, dst, byte_count);
201 } else {
202 do_conjoint_swap<T,direction,swap,false,false>(src, dst, byte_count);
203 }
204 }
205 }
206
207
208 /**
209 * Copy and byte swap elements
210 *
211 * <D> - copy direction
212 * <swap> - true if elements should be byte swapped
213 *
214 * @param src address of source
215 * @param dst address of destination
216 * @param byte_count number of bytes to copy
217 * @param elem_size size of the elements to copy-swap
218 */
219 template <CopyDirection D, bool swap>
|
54 }
55
56 class CopySwap : AllStatic {
57 public:
58 /**
59 * Copy and optionally byte swap elements
60 *
61 * <swap> - true if elements should be byte swapped
62 *
63 * @param src address of source
64 * @param dst address of destination
65 * @param byte_count number of bytes to copy
66 * @param elem_size size of the elements to copy-swap
67 */
68 template<bool swap>
69 static void conjoint_swap_if_needed(const void* src, void* dst, size_t byte_count, size_t elem_size) {
70 assert(src != NULL, "address must not be NULL");
71 assert(dst != NULL, "address must not be NULL");
72 assert(elem_size == 2 || elem_size == 4 || elem_size == 8,
73 "incorrect element size: " SIZE_FORMAT, elem_size);
74 assert(is_aligned(byte_count, elem_size),
75 "byte_count " SIZE_FORMAT " must be multiple of element size " SIZE_FORMAT, byte_count, elem_size);
76
77 address src_end = (address)src + byte_count;
78
79 if (dst <= src || dst >= src_end) {
80 do_conjoint_swap<RIGHT,swap>(src, dst, byte_count, elem_size);
81 } else {
82 do_conjoint_swap<LEFT,swap>(src, dst, byte_count, elem_size);
83 }
84 }
85
86 private:
87 /**
88 * Byte swap a 16-bit value
89 */
90 static uint16_t byte_swap(uint16_t x) {
91 return (x << 8) | (x >> 8);
92 }
93
94 /**
172 cur_src -= sizeof(T);
173 cur_dst -= sizeof(T);
174 break;
175 }
176 }
177 }
178
179 /**
180 * Copy and byte swap elements
181 *
182 * <T> - type of element to copy
183 * <D> - copy direction
184 * <swap> - true if elements should be byte swapped
185 *
186 * @param src address of source
187 * @param dst address of destination
188 * @param byte_count number of bytes to copy
189 */
190 template <typename T, CopyDirection direction, bool swap>
191 static void do_conjoint_swap(const void* src, void* dst, size_t byte_count) {
192 if (is_aligned(src, sizeof(T))) {
193 if (is_aligned(dst, sizeof(T))) {
194 do_conjoint_swap<T,direction,swap,true,true>(src, dst, byte_count);
195 } else {
196 do_conjoint_swap<T,direction,swap,true,false>(src, dst, byte_count);
197 }
198 } else {
199 if (is_aligned(dst, sizeof(T))) {
200 do_conjoint_swap<T,direction,swap,false,true>(src, dst, byte_count);
201 } else {
202 do_conjoint_swap<T,direction,swap,false,false>(src, dst, byte_count);
203 }
204 }
205 }
206
207
208 /**
209 * Copy and byte swap elements
210 *
211 * <D> - copy direction
212 * <swap> - true if elements should be byte swapped
213 *
214 * @param src address of source
215 * @param dst address of destination
216 * @param byte_count number of bytes to copy
217 * @param elem_size size of the elements to copy-swap
218 */
219 template <CopyDirection D, bool swap>
|