[Python-checkins] cpython (merge 3.6 -> default): Issue #28126: Replace Py_MEMCPY with memcpy(). Visual Studio can properly
christian.heimes
python-checkins at python.org
Tue Sep 13 14:22:41 EDT 2016
https://hg.python.org/cpython/rev/f5d32ed0f9c2
changeset: 103772:f5d32ed0f9c2
parent: 103770:2c9e07db0ac4
parent: 103771:bedce61ae0a0
user: Christian Heimes <christian at python.org>
date: Tue Sep 13 20:22:26 2016 +0200
summary:
Issue #28126: Replace Py_MEMCPY with memcpy(). Visual Studio can properly optimize memcpy().
files:
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
--- a/Include/pyport.h
+++ b/Include/pyport.h
@@ -177,26 +177,9 @@
#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 <stdlib.h>
@@ -449,18 +432,18 @@
#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 @@
#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
--- a/Include/unicodeobject.h
+++ b/Include/unicodeobject.h
@@ -156,7 +156,7 @@
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
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -10,6 +10,9 @@
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
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -836,10 +836,10 @@
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
--- 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 @@
}
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
--- a/Modules/hashtable.h
+++ b/Modules/hashtable.h
@@ -43,26 +43,26 @@
#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
--- a/Modules/zlibmodule.c
+++ b/Modules/zlibmodule.c
@@ -721,9 +721,9 @@
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
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -2353,7 +2353,7 @@
/* 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 @@
}
/* 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
--- a/Objects/bytesobject.c
+++ b/Objects/bytesobject.c
@@ -120,7 +120,7 @@
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 @@
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 @@
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 @@
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 @@
}
/* 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 @@
}
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 @@
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 @@
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 @@
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
--- a/Objects/stringlib/join.h
+++ b/Objects/stringlib/join.h
@@ -107,7 +107,7 @@
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 @@
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
--- a/Objects/stringlib/transmogrify.h
+++ b/Objects/stringlib/transmogrify.h
@@ -108,7 +108,7 @@
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 @@
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 @@
}
/* 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -1048,7 +1048,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
/* 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 @@
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 @@
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 @@
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 @@
_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
--- a/Python/marshal.c
+++ b/Python/marshal.c
@@ -130,7 +130,7 @@
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 @@
}
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
--- a/Python/pyhash.c
+++ b/Python/pyhash.c
@@ -396,7 +396,7 @@
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];
--
Repository URL: https://hg.python.org/cpython
More information about the Python-checkins
mailing list