Lines Matching refs:out
85 * between `out` and `from` is at least CHUNKCOPY_CHUNK_SIZE, which we rely on
94 unsigned char FAR* out,
98 storechunk(out, loadchunk(from));
99 out += bump;
103 storechunk(out, loadchunk(from));
104 out += CHUNKCOPY_CHUNK_SIZE;
107 return out;
114 * copy would use (out + len), but it's normally the case that the end of the
119 unsigned char FAR* out,
123 Assert(out + len <= limit, "chunk copy exceeds safety limit");
124 if ((limit - out) < (ptrdiff_t)CHUNKCOPY_CHUNK_SIZE) {
126 Assert((uintptr_t)out - (uintptr_t)from >= len,
128 Assert((uintptr_t)from - (uintptr_t)out >= len,
131 Z_BUILTIN_MEMCPY(out, rfrom, 8);
132 out += 8;
136 Z_BUILTIN_MEMCPY(out, rfrom, 4);
137 out += 4;
141 Z_BUILTIN_MEMCPY(out, rfrom, 2);
142 out += 2;
146 *out++ = *rfrom++;
148 return out;
150 return chunkcopy_core(out, from, len);
164 unsigned char FAR* out,
167 const unsigned char FAR* from = out - *dist;
169 storechunk(out, loadchunk(from));
170 out += *dist;
174 return out;
216 * not be 16-byte aligned) void* out.
218 static inline void v_store_128(void* out, const z_vec128i_t vec) {
219 vst1q_u8(out, vec);
263 * not be 16-byte aligned) void* out.
265 static inline void v_store_128(void* out, const z_vec128i_t vec) {
266 _mm_storeu_si128((__m128i*)out, vec);
277 unsigned char FAR* out,
285 v = v_load8_dup(out - 1);
286 v_store_128(out, v);
287 out += bump;
290 v_store_128(out, v);
291 out += sizeof(v);
294 return out;
296 v = v_load16_dup(out - 2);
297 v_store_128(out, v);
298 out += bump;
301 v = v_load16_dup(out - 2);
303 v_store_128(out, v);
304 out += sizeof(v);
308 return out;
310 v = v_load32_dup(out - 4);
311 v_store_128(out, v);
312 out += bump;
315 v = v_load32_dup(out - 4);
317 v_store_128(out, v);
318 out += sizeof(v);
322 return out;
324 v = v_load64_dup(out - 8);
325 v_store_128(out, v);
326 out += bump;
329 v = v_load64_dup(out - 8);
331 v_store_128(out, v);
332 out += sizeof(v);
336 return out;
338 out = chunkunroll_relaxed(out, &period, &len);
339 return chunkcopy_core(out, out - period, len);
353 unsigned char FAR* Z_RESTRICT out,
356 Assert((uintptr_t)out - (uintptr_t)from >= len,
358 Assert((uintptr_t)from - (uintptr_t)out >= len,
360 return chunkcopy_core(out, from, len);
372 * copy would use (out + len), but it's normally the case that the end of the
377 unsigned char FAR* out,
381 Assert(out + len <= limit, "chunk copy exceeds safety limit");
382 Assert((uintptr_t)out - (uintptr_t)from >= len,
384 Assert((uintptr_t)from - (uintptr_t)out >= len,
387 return chunkcopy_core_safe(out, from, len, limit);
398 unsigned char FAR* out,
402 return chunkset_core(out, dist, len);
404 return chunkcopy_core(out, out - dist, len);
412 * copy would use (out + len), but it's normally the case that the end of the
417 unsigned char FAR* out,
421 Assert(out + len <= limit, "chunk copy exceeds safety limit");
422 if ((limit - out) < (ptrdiff_t)(3 * CHUNKCOPY_CHUNK_SIZE)) {
425 *out = *(out - dist);
426 out++;
428 return out;
430 return chunkcopy_lapped_relaxed(out, dist, len);
434 static inline unsigned char FAR* chunkcopy_safe_ugly(unsigned char FAR* out,
443 return chunkcopy_core_safe(out, out - dist, len, limit);
446 return chunkcopy_core_safe(out, out - dist, len, limit);
449 return chunkcopy_lapped_safe(out, dist, len, limit);