Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2026-04-24 21:01:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

[3.7] bpo-9566: Fix compiler warnings on Windows (GH-12920)

Browse source 
* bpo-9566: Fix compiler warnings in gcmodule.c (GH-11010)

Change PyDTrace_GC_DONE() argument type from int to Py_ssize_t.

(cherry picked from commit edad38e3e0)

* bpo-30465: Fix C downcast warning on Windows in ast.c (#6593)

ast.c: fstring_fix_node_location() downcasts a pointer difference to
a C int. Replace int with Py_ssize_t to fix the compiler warning.

(cherry picked from commit fb7e7992be)

* bpo-9566: Fix compiler warnings in peephole.c (GH-10652)

(cherry picked from commit 028f0ef4f3)

* bpo-27645, sqlite: Fix integer overflow on sleep (#6594)

Use the _PyTime_t type and round away from zero (ROUND_UP,
_PyTime_ROUND_TIMEOUT) the sleep duration, when converting a Python
object to seconds and then to milliseconds. Raise an OverflowError in
case of overflow.

Previously the (int)double conversion rounded towards zero
(ROUND_DOWN).

(cherry picked from commit ca405017d5)
This commit is contained in:
Victor Stinner 2019-04-23 10:26:11 +02:00 • committed by GitHub
parent 9344d74f7b
commit 8a9a6b443c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 69 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Python/ast.c
View file

@ -4282,7 +4282,7 @@ fstring_fix_node_location(const node *parent, node *n, char *expr_str)
break;
start--;
}
cols += substr - start;
cols += (int)(substr - start);
/* Fix lineno in mulitline strings. */
while ((substr = strchr(substr + 1, '\n')))
lines--;

68
Python/peephole.c
View file

@ -152,6 +152,15 @@ fold_tuple_on_constants(_Py_CODEUNIT *codestr, Py_ssize_t codelen,
PyTuple_SET_ITEM(newconst, i, constant);
}
Py_ssize_t index = PyList_GET_SIZE(consts);
#if SIZEOF_SIZE_T > SIZEOF_INT
if ((size_t)index >= UINT_MAX - 1) {
Py_DECREF(newconst);
PyErr_SetString(PyExc_OverflowError, "too many constants");
return -1;
}
#endif
/* Append folded constant onto consts */
if (PyList_Append(consts, newconst)) {
Py_DECREF(newconst);
@ -160,7 +169,7 @@ fold_tuple_on_constants(_Py_CODEUNIT *codestr, Py_ssize_t codelen,
Py_DECREF(newconst);
return copy_op_arg(codestr, c_start, LOAD_CONST,
PyList_GET_SIZE(consts)-1, opcode_end);
(unsigned int)index, opcode_end);
}
static unsigned int *
@ -223,7 +232,7 @@ PyObject *
PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
PyObject *lnotab_obj)
{
Py_ssize_t h, i, nexti, op_start, codelen, tgt;
Py_ssize_t h, i, nexti, op_start, tgt;
unsigned int j, nops;
unsigned char opcode, nextop;
_Py_CODEUNIT *codestr = NULL;
@ -251,17 +260,22 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
the peephole optimizer doesn't modify line numbers. */
assert(PyBytes_Check(code));
codelen = PyBytes_GET_SIZE(code);
assert(codelen % sizeof(_Py_CODEUNIT) == 0);
Py_ssize_t codesize = PyBytes_GET_SIZE(code);
assert(codesize % sizeof(_Py_CODEUNIT) == 0);
Py_ssize_t codelen = codesize / sizeof(_Py_CODEUNIT);
if (codelen > INT_MAX) {
/* Python assembler is limited to INT_MAX: see assembler.a_offset in
compile.c. */
goto exitUnchanged;
}
/* Make a modifiable copy of the code string */
codestr = (_Py_CODEUNIT *)PyMem_Malloc(codelen);
codestr = (_Py_CODEUNIT *)PyMem_Malloc(codesize);
if (codestr == NULL) {
PyErr_NoMemory();
goto exitError;
}
memcpy(codestr, PyBytes_AS_STRING(code), codelen);
codelen /= sizeof(_Py_CODEUNIT);
memcpy(codestr, PyBytes_AS_STRING(code), codesize);
blocks = markblocks(codestr, codelen);
if (blocks == NULL)
@ -359,7 +373,11 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
jump past it), and all conditional jumps pop their
argument when they're not taken (so change the
first jump to pop its argument when it's taken). */
h = set_arg(codestr, i, (tgt + 1) * sizeof(_Py_CODEUNIT));
Py_ssize_t arg = (tgt + 1);
/* cannot overflow: codelen <= INT_MAX */
assert((size_t)arg <= UINT_MAX / sizeof(_Py_CODEUNIT));
arg *= sizeof(_Py_CODEUNIT);
h = set_arg(codestr, i, (unsigned int)arg);
j = opcode == JUMP_IF_TRUE_OR_POP ?
POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE;
}
@ -392,17 +410,20 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
codestr[op_start] = PACKOPARG(RETURN_VALUE, 0);
fill_nops(codestr, op_start + 1, i + 1);
} else if (UNCONDITIONAL_JUMP(_Py_OPCODE(codestr[tgt]))) {
j = GETJUMPTGT(codestr, tgt);
size_t arg = GETJUMPTGT(codestr, tgt);
if (opcode == JUMP_FORWARD) { /* JMP_ABS can go backwards */
opcode = JUMP_ABSOLUTE;
} else if (!ABSOLUTE_JUMP(opcode)) {
if ((Py_ssize_t)j < i + 1) {
if (arg < (size_t)(i + 1)) {
break; /* No backward relative jumps */
}
j -= i + 1; /* Calc relative jump addr */
arg -= i + 1; /* Calc relative jump addr */
}
j *= sizeof(_Py_CODEUNIT);
copy_op_arg(codestr, op_start, opcode, j, i + 1);
/* cannot overflow: codelen <= INT_MAX */
assert(arg <= (UINT_MAX / sizeof(_Py_CODEUNIT)));
arg *= sizeof(_Py_CODEUNIT);
copy_op_arg(codestr, op_start, opcode,
(unsigned int)arg, i + 1);
}
break;
@ -422,11 +443,14 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
/* Fixup lnotab */
for (i = 0, nops = 0; i < codelen; i++) {
assert(i - nops <= INT_MAX);
size_t block = (size_t)i - nops;
/* cannot overflow: codelen <= INT_MAX */
assert(block <= UINT_MAX);
/* original code offset => new code offset */
blocks[i] = i - nops;
if (_Py_OPCODE(codestr[i]) == NOP)
blocks[i] = (unsigned int)block;
if (_Py_OPCODE(codestr[i]) == NOP) {
nops++;
}
}
cum_orig_offset = 0;
last_offset = 0;
@ -473,12 +497,14 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
j *= sizeof(_Py_CODEUNIT);
break;
}
nexti = i - op_start + 1;
if (instrsize(j) > nexti)
Py_ssize_t ilen = i - op_start + 1;
if (instrsize(j) > ilen) {
goto exitUnchanged;
/* If instrsize(j) < nexti, we'll emit EXTENDED_ARG 0 */
write_op_arg(codestr + h, opcode, j, nexti);
h += nexti;
}
assert(ilen <= INT_MAX);
/* If instrsize(j) < ilen, we'll emit EXTENDED_ARG 0 */
write_op_arg(codestr + h, opcode, j, (int)ilen);
h += ilen;
}
assert(h + (Py_ssize_t)nops == codelen);