From f051e43b22af014364e231c36489e6745993ea34 Mon Sep 17 00:00:00 2001 From: Christian Heimes Date: Tue, 13 Sep 2016 20:22:02 +0200 Subject: [PATCH] Issue #28126: Replace Py_MEMCPY with memcpy(). Visual Studio can properly optimize memcpy(). --- Include/pyport.h | 45 ++++++++++---------------------- Include/unicodeobject.h | 2 +- Misc/NEWS | 3 +++ Modules/arraymodule.c | 4 +-- Modules/hashtable.c | 6 ++--- Modules/hashtable.h | 8 +++--- Modules/zlibmodule.c | 4 +-- Objects/abstract.c | 4 +-- Objects/bytesobject.c | 20 +++++++------- Objects/stringlib/join.h | 6 ++--- Objects/stringlib/transmogrify.h | 40 ++++++++++++++-------------- Objects/unicodeobject.c | 32 +++++++++++------------ Python/marshal.c | 4 +-- Python/pyhash.c | 2 +- 14 files changed, 83 insertions(+), 97 deletions(-) diff --git a/Include/pyport.h b/Include/pyport.h index b631cf3c980..be1d66d5634 100644 --- a/Include/pyport.h +++ b/Include/pyport.h @@ -177,26 +177,9 @@ typedef int Py_ssize_clean_t; #define Py_LOCAL_INLINE(type) static type #endif -/* Py_MEMCPY can be used instead of memcpy in cases where the copied blocks - * are often very short. While most platforms have highly optimized code for - * large transfers, the setup costs for memcpy are often quite high. MEMCPY - * solves this by doing short copies "in line". - */ - -#if defined(_MSC_VER) -#define Py_MEMCPY(target, source, length) do { \ - size_t i_, n_ = (length); \ - char *t_ = (void*) (target); \ - const char *s_ = (void*) (source); \ - if (n_ >= 16) \ - memcpy(t_, s_, n_); \ - else \ - for (i_ = 0; i_ < n_; i_++) \ - t_[i_] = s_[i_]; \ - } while (0) -#else +/* Py_MEMCPY is kept for backwards compatibility, + * see https://bugs.python.org/issue28126 */ #define Py_MEMCPY memcpy -#endif #include @@ -449,18 +432,18 @@ extern "C" { #define HAVE_PY_SET_53BIT_PRECISION 1 #define _Py_SET_53BIT_PRECISION_HEADER \ unsigned int old_fpcr, new_fpcr -#define _Py_SET_53BIT_PRECISION_START \ - do { \ - __asm__ ("fmove.l %%fpcr,%0" : "=g" (old_fpcr)); \ - /* Set double precision / round to nearest. */ \ - new_fpcr = (old_fpcr & ~0xf0) | 0x80; \ - if (new_fpcr != old_fpcr) \ - __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (new_fpcr)); \ +#define _Py_SET_53BIT_PRECISION_START \ + do { \ + __asm__ ("fmove.l %%fpcr,%0" : "=g" (old_fpcr)); \ + /* Set double precision / round to nearest. */ \ + new_fpcr = (old_fpcr & ~0xf0) | 0x80; \ + if (new_fpcr != old_fpcr) \ + __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (new_fpcr)); \ } while (0) -#define _Py_SET_53BIT_PRECISION_END \ - do { \ - if (new_fpcr != old_fpcr) \ - __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (old_fpcr)); \ +#define _Py_SET_53BIT_PRECISION_END \ + do { \ + if (new_fpcr != old_fpcr) \ + __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (old_fpcr)); \ } while (0) #endif @@ -742,7 +725,7 @@ extern pid_t forkpty(int *, char *, struct termios *, struct winsize *); #endif #ifdef VA_LIST_IS_ARRAY -#define Py_VA_COPY(x, y) Py_MEMCPY((x), (y), sizeof(va_list)) +#define Py_VA_COPY(x, y) memcpy((x), (y), sizeof(va_list)) #else #ifdef __va_copy #define Py_VA_COPY __va_copy diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h index 38f733bd4fc..bc6ecd4e81e 100644 --- a/Include/unicodeobject.h +++ b/Include/unicodeobject.h @@ -156,7 +156,7 @@ typedef uint8_t Py_UCS1; Py_UNICODE_ISNUMERIC(ch)) #define Py_UNICODE_COPY(target, source, length) \ - Py_MEMCPY((target), (source), (length)*sizeof(Py_UNICODE)) + memcpy((target), (source), (length)*sizeof(Py_UNICODE)) #define Py_UNICODE_FILL(target, value, length) \ do {Py_ssize_t i_; Py_UNICODE *t_ = (target); Py_UNICODE v_ = (value);\ diff --git a/Misc/NEWS b/Misc/NEWS index 57f1b539385..913ee01278a 100644 --- a/Misc/NEWS +++ b/Misc/NEWS @@ -10,6 +10,9 @@ What's New in Python 3.6.0 beta 2 Core and Builtins ----------------- +- Issue #28126: Replace Py_MEMCPY with memcpy(). Visual Studio can properly + optimize memcpy(). + - Issue #28120: Fix dict.pop() for splitted dictionary when trying to remove a "pending key" (Not yet inserted in split-table). Patch by Xiang Zhang. diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c index 5868c52ca8a..2caa8ee5a8e 100644 --- a/Modules/arraymodule.c +++ b/Modules/arraymodule.c @@ -836,10 +836,10 @@ array_repeat(arrayobject *a, Py_ssize_t n) memset(np->ob_item, a->ob_item[0], newbytes); } else { Py_ssize_t done = oldbytes; - Py_MEMCPY(np->ob_item, a->ob_item, oldbytes); + memcpy(np->ob_item, a->ob_item, oldbytes); while (done < newbytes) { Py_ssize_t ncopy = (done <= newbytes-done) ? done : newbytes-done; - Py_MEMCPY(np->ob_item+done, np->ob_item, ncopy); + memcpy(np->ob_item+done, np->ob_item, ncopy); done += ncopy; } } diff --git a/Modules/hashtable.c b/Modules/hashtable.c index 3462fef19e8..0547a6def2a 100644 --- a/Modules/hashtable.c +++ b/Modules/hashtable.c @@ -64,14 +64,14 @@ #define ENTRY_READ_PDATA(TABLE, ENTRY, DATA_SIZE, PDATA) \ do { \ assert((DATA_SIZE) == (TABLE)->data_size); \ - Py_MEMCPY((PDATA), _Py_HASHTABLE_ENTRY_PDATA(TABLE, (ENTRY)), \ + memcpy((PDATA), _Py_HASHTABLE_ENTRY_PDATA(TABLE, (ENTRY)), \ (DATA_SIZE)); \ } while (0) #define ENTRY_WRITE_PDATA(TABLE, ENTRY, DATA_SIZE, PDATA) \ do { \ assert((DATA_SIZE) == (TABLE)->data_size); \ - Py_MEMCPY((void *)_Py_HASHTABLE_ENTRY_PDATA((TABLE), (ENTRY)), \ + memcpy((void *)_Py_HASHTABLE_ENTRY_PDATA((TABLE), (ENTRY)), \ (PDATA), (DATA_SIZE)); \ } while (0) @@ -337,7 +337,7 @@ _Py_hashtable_set(_Py_hashtable_t *ht, size_t key_size, const void *pkey, } entry->key_hash = key_hash; - Py_MEMCPY((void *)_Py_HASHTABLE_ENTRY_PKEY(entry), pkey, ht->key_size); + memcpy((void *)_Py_HASHTABLE_ENTRY_PKEY(entry), pkey, ht->key_size); if (data) ENTRY_WRITE_PDATA(ht, entry, data_size, data); diff --git a/Modules/hashtable.h b/Modules/hashtable.h index 18fed096c1a..dbec23d2851 100644 --- a/Modules/hashtable.h +++ b/Modules/hashtable.h @@ -43,26 +43,26 @@ typedef struct { #define _Py_HASHTABLE_READ_KEY(TABLE, PKEY, DST_KEY) \ do { \ assert(sizeof(DST_KEY) == (TABLE)->key_size); \ - Py_MEMCPY(&(DST_KEY), (PKEY), sizeof(DST_KEY)); \ + memcpy(&(DST_KEY), (PKEY), sizeof(DST_KEY)); \ } while (0) #define _Py_HASHTABLE_ENTRY_READ_KEY(TABLE, ENTRY, KEY) \ do { \ assert(sizeof(KEY) == (TABLE)->key_size); \ - Py_MEMCPY(&(KEY), _Py_HASHTABLE_ENTRY_PKEY(ENTRY), sizeof(KEY)); \ + memcpy(&(KEY), _Py_HASHTABLE_ENTRY_PKEY(ENTRY), sizeof(KEY)); \ } while (0) #define _Py_HASHTABLE_ENTRY_READ_DATA(TABLE, ENTRY, DATA) \ do { \ assert(sizeof(DATA) == (TABLE)->data_size); \ - Py_MEMCPY(&(DATA), _Py_HASHTABLE_ENTRY_PDATA(TABLE, (ENTRY)), \ + memcpy(&(DATA), _Py_HASHTABLE_ENTRY_PDATA(TABLE, (ENTRY)), \ sizeof(DATA)); \ } while (0) #define _Py_HASHTABLE_ENTRY_WRITE_DATA(TABLE, ENTRY, DATA) \ do { \ assert(sizeof(DATA) == (TABLE)->data_size); \ - Py_MEMCPY((void *)_Py_HASHTABLE_ENTRY_PDATA((TABLE), (ENTRY)), \ + memcpy((void *)_Py_HASHTABLE_ENTRY_PDATA((TABLE), (ENTRY)), \ &(DATA), sizeof(DATA)); \ } while (0) diff --git a/Modules/zlibmodule.c b/Modules/zlibmodule.c index 4cded311eab..cfe7f88dc54 100644 --- a/Modules/zlibmodule.c +++ b/Modules/zlibmodule.c @@ -721,9 +721,9 @@ save_unconsumed_input(compobject *self, Py_buffer *data, int err) new_data = PyBytes_FromStringAndSize(NULL, new_size); if (new_data == NULL) return -1; - Py_MEMCPY(PyBytes_AS_STRING(new_data), + memcpy(PyBytes_AS_STRING(new_data), PyBytes_AS_STRING(self->unused_data), old_size); - Py_MEMCPY(PyBytes_AS_STRING(new_data) + old_size, + memcpy(PyBytes_AS_STRING(new_data) + old_size, self->zst.next_in, left_size); Py_SETREF(self->unused_data, new_data); self->zst.avail_in = 0; diff --git a/Objects/abstract.c b/Objects/abstract.c index 17da5c999a0..36f22426ac5 100644 --- a/Objects/abstract.c +++ b/Objects/abstract.c @@ -2353,7 +2353,7 @@ _PyObject_Call_Prepend(PyObject *func, /* use borrowed references */ stack[0] = obj; - Py_MEMCPY(&stack[1], + memcpy(&stack[1], &PyTuple_GET_ITEM(args, 0), argcount * sizeof(PyObject *)); @@ -2428,7 +2428,7 @@ _PyStack_UnpackDict(PyObject **args, Py_ssize_t nargs, PyObject *kwargs, } /* Copy position arguments (borrowed references) */ - Py_MEMCPY(stack, args, nargs * sizeof(stack[0])); + memcpy(stack, args, nargs * sizeof(stack[0])); kwstack = stack + nargs; pos = i = 0; diff --git a/Objects/bytesobject.c b/Objects/bytesobject.c index 4d14451254f..1550083e347 100644 --- a/Objects/bytesobject.c +++ b/Objects/bytesobject.c @@ -120,7 +120,7 @@ PyBytes_FromStringAndSize(const char *str, Py_ssize_t size) if (str == NULL) return (PyObject *) op; - Py_MEMCPY(op->ob_sval, str, size); + memcpy(op->ob_sval, str, size); /* share short strings */ if (size == 1) { characters[*str & UCHAR_MAX] = op; @@ -163,7 +163,7 @@ PyBytes_FromString(const char *str) return PyErr_NoMemory(); (void)PyObject_INIT_VAR(op, &PyBytes_Type, size); op->ob_shash = -1; - Py_MEMCPY(op->ob_sval, str, size+1); + memcpy(op->ob_sval, str, size+1); /* share short strings */ if (size == 0) { nullstring = op; @@ -437,7 +437,7 @@ formatfloat(PyObject *v, int flags, int prec, int type, str = _PyBytesWriter_Prepare(writer, str, len); if (str == NULL) return NULL; - Py_MEMCPY(str, p, len); + memcpy(str, p, len); PyMem_Free(p); str += len; return str; @@ -626,7 +626,7 @@ _PyBytes_FormatEx(const char *format, Py_ssize_t format_len, len = format_len - (fmt - format); assert(len != 0); - Py_MEMCPY(res, fmt, len); + memcpy(res, fmt, len); res += len; fmt += len; fmtcnt -= (len - 1); @@ -1009,7 +1009,7 @@ _PyBytes_FormatEx(const char *format, Py_ssize_t format_len, } /* Copy bytes */ - Py_MEMCPY(res, pbuf, len); + memcpy(res, pbuf, len); res += len; /* Pad right with the fill character if needed */ @@ -1473,12 +1473,12 @@ bytes_repeat(PyBytesObject *a, Py_ssize_t n) } i = 0; if (i < size) { - Py_MEMCPY(op->ob_sval, a->ob_sval, Py_SIZE(a)); + memcpy(op->ob_sval, a->ob_sval, Py_SIZE(a)); i = Py_SIZE(a); } while (i < size) { j = (i <= size-i) ? i : size-i; - Py_MEMCPY(op->ob_sval+i, op->ob_sval, j); + memcpy(op->ob_sval+i, op->ob_sval, j); i += j; } return (PyObject *) op; @@ -2765,7 +2765,7 @@ bytes_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) n = PyBytes_GET_SIZE(tmp); pnew = type->tp_alloc(type, n); if (pnew != NULL) { - Py_MEMCPY(PyBytes_AS_STRING(pnew), + memcpy(PyBytes_AS_STRING(pnew), PyBytes_AS_STRING(tmp), n+1); ((PyBytesObject *)pnew)->ob_shash = ((PyBytesObject *)tmp)->ob_shash; @@ -3237,7 +3237,7 @@ _PyBytesWriter_Resize(_PyBytesWriter *writer, void *str, Py_ssize_t size) dest = PyByteArray_AS_STRING(writer->buffer); else dest = PyBytes_AS_STRING(writer->buffer); - Py_MEMCPY(dest, + memcpy(dest, writer->small_buffer, pos); } @@ -3372,7 +3372,7 @@ _PyBytesWriter_WriteBytes(_PyBytesWriter *writer, void *ptr, if (str == NULL) return NULL; - Py_MEMCPY(str, bytes, size); + memcpy(str, bytes, size); str += size; return str; diff --git a/Objects/stringlib/join.h b/Objects/stringlib/join.h index 90f966dd5ce..6f314e1524e 100644 --- a/Objects/stringlib/join.h +++ b/Objects/stringlib/join.h @@ -107,7 +107,7 @@ STRINGLIB(bytes_join)(PyObject *sep, PyObject *iterable) for (i = 0; i < nbufs; i++) { Py_ssize_t n = buffers[i].len; char *q = buffers[i].buf; - Py_MEMCPY(p, q, n); + memcpy(p, q, n); p += n; } goto done; @@ -116,12 +116,12 @@ STRINGLIB(bytes_join)(PyObject *sep, PyObject *iterable) Py_ssize_t n; char *q; if (i) { - Py_MEMCPY(p, sepstr, seplen); + memcpy(p, sepstr, seplen); p += seplen; } n = buffers[i].len; q = buffers[i].buf; - Py_MEMCPY(p, q, n); + memcpy(p, q, n); p += n; } goto done; diff --git a/Objects/stringlib/transmogrify.h b/Objects/stringlib/transmogrify.h index 9903912dc4a..a314572a72b 100644 --- a/Objects/stringlib/transmogrify.h +++ b/Objects/stringlib/transmogrify.h @@ -108,7 +108,7 @@ pad(PyObject *self, Py_ssize_t left, Py_ssize_t right, char fill) if (u) { if (left) memset(STRINGLIB_STR(u), fill, left); - Py_MEMCPY(STRINGLIB_STR(u) + left, + memcpy(STRINGLIB_STR(u) + left, STRINGLIB_STR(self), STRINGLIB_LEN(self)); if (right) @@ -275,13 +275,13 @@ stringlib_replace_interleave(PyObject *self, if (to_len > 1) { /* Lay the first one down (guaranteed this will occur) */ - Py_MEMCPY(result_s, to_s, to_len); + memcpy(result_s, to_s, to_len); result_s += to_len; count -= 1; for (i = 0; i < count; i++) { *result_s++ = *self_s++; - Py_MEMCPY(result_s, to_s, to_len); + memcpy(result_s, to_s, to_len); result_s += to_len; } } @@ -297,7 +297,7 @@ stringlib_replace_interleave(PyObject *self, } /* Copy the rest of the original string */ - Py_MEMCPY(result_s, self_s, self_len - i); + memcpy(result_s, self_s, self_len - i); return result; } @@ -337,11 +337,11 @@ stringlib_replace_delete_single_character(PyObject *self, next = findchar(start, end - start, from_c); if (next == NULL) break; - Py_MEMCPY(result_s, start, next - start); + memcpy(result_s, start, next - start); result_s += (next - start); start = next + 1; } - Py_MEMCPY(result_s, start, end - start); + memcpy(result_s, start, end - start); return result; } @@ -390,12 +390,12 @@ stringlib_replace_delete_substring(PyObject *self, break; next = start + offset; - Py_MEMCPY(result_s, start, next - start); + memcpy(result_s, start, next - start); result_s += (next - start); start = next + from_len; } - Py_MEMCPY(result_s, start, end - start); + memcpy(result_s, start, end - start); return result; } @@ -427,7 +427,7 @@ stringlib_replace_single_character_in_place(PyObject *self, return NULL; } result_s = STRINGLIB_STR(result); - Py_MEMCPY(result_s, self_s, self_len); + memcpy(result_s, self_s, self_len); /* change everything in-place, starting with this one */ start = result_s + (next - self_s); @@ -477,11 +477,11 @@ stringlib_replace_substring_in_place(PyObject *self, return NULL; } result_s = STRINGLIB_STR(result); - Py_MEMCPY(result_s, self_s, self_len); + memcpy(result_s, self_s, self_len); /* change everything in-place, starting with this one */ start = result_s + offset; - Py_MEMCPY(start, to_s, from_len); + memcpy(start, to_s, from_len); start += from_len; end = result_s + self_len; @@ -491,7 +491,7 @@ stringlib_replace_substring_in_place(PyObject *self, 0); if (offset == -1) break; - Py_MEMCPY(start + offset, to_s, from_len); + memcpy(start + offset, to_s, from_len); start += offset + from_len; } @@ -544,20 +544,20 @@ stringlib_replace_single_character(PyObject *self, if (next == start) { /* replace with the 'to' */ - Py_MEMCPY(result_s, to_s, to_len); + memcpy(result_s, to_s, to_len); result_s += to_len; start += 1; } else { /* copy the unchanged old then the 'to' */ - Py_MEMCPY(result_s, start, next - start); + memcpy(result_s, start, next - start); result_s += (next - start); - Py_MEMCPY(result_s, to_s, to_len); + memcpy(result_s, to_s, to_len); result_s += to_len; start = next + 1; } } /* Copy the remainder of the remaining bytes */ - Py_MEMCPY(result_s, start, end - start); + memcpy(result_s, start, end - start); return result; } @@ -613,20 +613,20 @@ stringlib_replace_substring(PyObject *self, next = start + offset; if (next == start) { /* replace with the 'to' */ - Py_MEMCPY(result_s, to_s, to_len); + memcpy(result_s, to_s, to_len); result_s += to_len; start += from_len; } else { /* copy the unchanged old then the 'to' */ - Py_MEMCPY(result_s, start, next - start); + memcpy(result_s, start, next - start); result_s += (next - start); - Py_MEMCPY(result_s, to_s, to_len); + memcpy(result_s, to_s, to_len); result_s += to_len; start = next + from_len; } } /* Copy the remainder of the remaining bytes */ - Py_MEMCPY(result_s, start, end - start); + memcpy(result_s, start, end - start); return result; } diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c index aaebfd017fa..85cdbb73b7f 100644 --- a/Objects/unicodeobject.c +++ b/Objects/unicodeobject.c @@ -1048,7 +1048,7 @@ resize_copy(PyObject *unicode, Py_ssize_t length) return NULL; copy_length = _PyUnicode_WSTR_LENGTH(unicode); copy_length = Py_MIN(copy_length, length); - Py_MEMCPY(_PyUnicode_WSTR(w), _PyUnicode_WSTR(unicode), + memcpy(_PyUnicode_WSTR(w), _PyUnicode_WSTR(unicode), copy_length * sizeof(wchar_t)); return w; } @@ -1435,7 +1435,7 @@ _copy_characters(PyObject *to, Py_ssize_t to_start, if (max_char >= 128) return -1; } - Py_MEMCPY((char*)to_data + to_kind * to_start, + memcpy((char*)to_data + to_kind * to_start, (char*)from_data + from_kind * from_start, to_kind * how_many); } @@ -2024,7 +2024,7 @@ PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size) break; case PyUnicode_2BYTE_KIND: #if Py_UNICODE_SIZE == 2 - Py_MEMCPY(PyUnicode_2BYTE_DATA(unicode), u, size * 2); + memcpy(PyUnicode_2BYTE_DATA(unicode), u, size * 2); #else _PyUnicode_CONVERT_BYTES(Py_UNICODE, Py_UCS2, u, u + size, PyUnicode_2BYTE_DATA(unicode)); @@ -2037,7 +2037,7 @@ PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size) unicode_convert_wchar_to_ucs4(u, u + size, unicode); #else assert(num_surrogates == 0); - Py_MEMCPY(PyUnicode_4BYTE_DATA(unicode), u, size * 4); + memcpy(PyUnicode_4BYTE_DATA(unicode), u, size * 4); #endif break; default: @@ -2348,7 +2348,7 @@ _PyUnicode_Copy(PyObject *unicode) return NULL; assert(PyUnicode_KIND(copy) == PyUnicode_KIND(unicode)); - Py_MEMCPY(PyUnicode_DATA(copy), PyUnicode_DATA(unicode), + memcpy(PyUnicode_DATA(copy), PyUnicode_DATA(unicode), length * PyUnicode_KIND(unicode)); assert(_PyUnicode_CheckConsistency(copy, 1)); return copy; @@ -2454,7 +2454,7 @@ as_ucs4(PyObject *string, Py_UCS4 *target, Py_ssize_t targetsize, } else { assert(kind == PyUnicode_4BYTE_KIND); - Py_MEMCPY(target, data, len * sizeof(Py_UCS4)); + memcpy(target, data, len * sizeof(Py_UCS4)); } if (copy_null) target[len] = 0; @@ -2963,7 +2963,7 @@ unicode_aswidechar(PyObject *unicode, size = res + 1; else res = size; - Py_MEMCPY(w, wstr, size * sizeof(wchar_t)); + memcpy(w, wstr, size * sizeof(wchar_t)); return res; } else @@ -3986,7 +3986,7 @@ PyUnicode_AsUTF8AndSize(PyObject *unicode, Py_ssize_t *psize) return NULL; } _PyUnicode_UTF8_LENGTH(unicode) = PyBytes_GET_SIZE(bytes); - Py_MEMCPY(_PyUnicode_UTF8(unicode), + memcpy(_PyUnicode_UTF8(unicode), PyBytes_AS_STRING(bytes), _PyUnicode_UTF8_LENGTH(unicode) + 1); Py_DECREF(bytes); @@ -5473,7 +5473,7 @@ _PyUnicode_EncodeUTF32(PyObject *str, } if (PyBytes_Check(rep)) { - Py_MEMCPY(out, PyBytes_AS_STRING(rep), repsize); + memcpy(out, PyBytes_AS_STRING(rep), repsize); out += moreunits; } else /* rep is unicode */ { assert(PyUnicode_KIND(rep) == PyUnicode_1BYTE_KIND); @@ -5825,7 +5825,7 @@ _PyUnicode_EncodeUTF16(PyObject *str, } if (PyBytes_Check(rep)) { - Py_MEMCPY(out, PyBytes_AS_STRING(rep), repsize); + memcpy(out, PyBytes_AS_STRING(rep), repsize); out += moreunits; } else /* rep is unicode */ { assert(PyUnicode_KIND(rep) == PyUnicode_1BYTE_KIND); @@ -10012,7 +10012,7 @@ _PyUnicode_JoinArray(PyObject *separator, PyObject **items, Py_ssize_t seqlen) /* Copy item, and maybe the separator. */ if (i && seplen != 0) { - Py_MEMCPY(res_data, + memcpy(res_data, sep_data, kind * seplen); res_data += kind * seplen; @@ -10020,7 +10020,7 @@ _PyUnicode_JoinArray(PyObject *separator, PyObject **items, Py_ssize_t seqlen) itemlen = PyUnicode_GET_LENGTH(item); if (itemlen != 0) { - Py_MEMCPY(res_data, + memcpy(res_data, PyUnicode_DATA(item), kind * itemlen); res_data += kind * itemlen; @@ -12396,11 +12396,11 @@ unicode_repeat(PyObject *str, Py_ssize_t len) Py_ssize_t done = PyUnicode_GET_LENGTH(str); const Py_ssize_t char_size = PyUnicode_KIND(str); char *to = (char *) PyUnicode_DATA(u); - Py_MEMCPY(to, PyUnicode_DATA(str), + memcpy(to, PyUnicode_DATA(str), PyUnicode_GET_LENGTH(str) * char_size); while (done < nchars) { n = (done <= nchars-done) ? done : nchars-done; - Py_MEMCPY(to + (done * char_size), to, n * char_size); + memcpy(to + (done * char_size), to, n * char_size); done += n; } } @@ -13531,7 +13531,7 @@ _PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer, const Py_UCS1 *str = (const Py_UCS1 *)ascii; Py_UCS1 *data = writer->data; - Py_MEMCPY(data + writer->pos, str, len); + memcpy(data + writer->pos, str, len); break; } case PyUnicode_2BYTE_KIND: @@ -14928,7 +14928,7 @@ unicode_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) _PyUnicode_WSTR(self) = (wchar_t *)data; } - Py_MEMCPY(data, PyUnicode_DATA(unicode), + memcpy(data, PyUnicode_DATA(unicode), kind * (length + 1)); assert(_PyUnicode_CheckConsistency(self, 1)); #ifdef Py_DEBUG diff --git a/Python/marshal.c b/Python/marshal.c index 627a8428e53..87a4b240a41 100644 --- a/Python/marshal.c +++ b/Python/marshal.c @@ -130,7 +130,7 @@ w_string(const char *s, Py_ssize_t n, WFILE *p) m = p->end - p->ptr; if (p->fp != NULL) { if (n <= m) { - Py_MEMCPY(p->ptr, s, n); + memcpy(p->ptr, s, n); p->ptr += n; } else { @@ -140,7 +140,7 @@ w_string(const char *s, Py_ssize_t n, WFILE *p) } else { if (n <= m || w_reserve(p, n - m)) { - Py_MEMCPY(p->ptr, s, n); + memcpy(p->ptr, s, n); p->ptr += n; } } diff --git a/Python/pyhash.c b/Python/pyhash.c index 9080d251b66..57a2da715e1 100644 --- a/Python/pyhash.c +++ b/Python/pyhash.c @@ -396,7 +396,7 @@ siphash24(const void *src, Py_ssize_t src_sz) { case 7: pt[6] = m[6]; case 6: pt[5] = m[5]; case 5: pt[4] = m[4]; - case 4: Py_MEMCPY(pt, m, sizeof(uint32_t)); break; + case 4: memcpy(pt, m, sizeof(uint32_t)); break; case 3: pt[2] = m[2]; case 2: pt[1] = m[1]; case 1: pt[0] = m[0];