gcc-python-plugin-commits September 2011

gcc-python-plugin-commits@lists.stg.fedorahosted.org

1 participants
71 discussions

[gcc-python-plugin] cpychecker: implement PyString_FromStringAndSize; add detection of NULL argument to PyString_FromStr
by David Hugh Malcolm 23 Sep '11

23 Sep '11

commit 3cfe988d3cbd76ce29a47fdaf2dd2609a149244d Author: David Malcolm <dmalcolm(a)redhat.com> Date: Fri Sep 23 14:18:29 2011 -0400 cpychecker: implement PyString_FromStringAndSize; add detection of NULL argument to PyString_FromString libcpychecker/refcounts.py | 25 +++++++++++ .../PyString_FromStringAndSize/correct/input.c | 43 ++++++++++++++++++++ .../PyString_FromStringAndSize/correct/script.py | 22 ++++++++++ .../PyString_FromStringAndSize/correct/stdout.txt | 41 +++++++++++++++++++ 4 files changed, 131 insertions(+), 0 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index 277e4f4..6f6fd96 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -1439,6 +1439,31 @@ class MyState(State): def impl_PyString_FromString(self, stmt): # Declared in stringobject.h as: # PyAPI_FUNC(PyObject *) PyString_FromString(const char *); + # + # http://docs.python.org/c-api/string.html#PyString_FromString + # + v_str, = self.eval_stmt_args(stmt) + + # The input _must_ be non-NULL; it is not checked: + self.raise_any_null_ptr_func_arg(stmt, 0, v_str) + + newobj, t_success, t_failure = self.impl_object_ctor(stmt, + 'PyStringObject', 'PyString_Type') + return [t_success, t_failure] + + def impl_PyString_FromStringAndSize(self, stmt): + # Declared in stringobject.h as: + # PyAPI_FUNC(PyObject *) PyString_FromStringAndSize(const char *, Py_ssize_t); + # + # http://docs.python.org/c-api/string.html#PyString_FromStringAndSize + # + # Defined in Objects/stringobject.c: + # # PyObject * + # PyString_FromStringAndSize(const char *str, Py_ssize_t size) + + # v_str, v_size = self.eval_stmt_args(stmt) + # (the input can legitimately be NULL) + newobj, t_success, t_failure = self.impl_object_ctor(stmt, 'PyStringObject', 'PyString_Type') return [t_success, t_failure] diff --git a/tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c b/tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c new file mode 100644 index 0000000..0c9c9b7 --- /dev/null +++ b/tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c @@ -0,0 +1,43 @@ +/* + Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> + Copyright 2011 Red Hat, Inc. + + This is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + <http://www.gnu.org/licenses/>. +*/ + +#include <Python.h> + +/* + Test of correct call to PyString_FromStringAndSize +*/ +PyObject * +test(PyObject *self, PyObject *args) +{ + PyObject *result; + result = PyString_FromStringAndSize("foo", 3); + return result; +} +static PyMethodDef test_methods[] = { + {"test_method", test, METH_VARARGS, NULL}, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/script.py b/tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/script.py new file mode 100644 index 0000000..fdd5ba3 --- /dev/null +++ b/tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/script.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> +# Copyright 2011 Red Hat, Inc. +# +# This is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see +# <http://www.gnu.org/licenses/>. + +from libcpychecker import main +main(verify_refcounting=True, + dump_traces=True, + show_traces=False) diff --git a/tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/stdout.txt b/tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/stdout.txt new file mode 100644 index 0000000..7705952 --- /dev/null +++ b/tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/stdout.txt @@ -0,0 +1,41 @@ +Trace 0: + Transitions: + 'PyString_FromStringAndSize() succeeds' + 'returning' + Return value: + repr(): PointerToRegion(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c', line=29), region=RegionOnHeap('PyStringObject', gcc.Location(file='tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c', line=29))) + str(): (struct PyObject *)&RegionOnHeap('PyStringObject', gcc.Location(file='tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c', line=29)) from tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c:29 + r->ob_refcnt: refs: 1 + N where N >= 0 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c', line=29), region=RegionForGlobal(gcc.VarDecl('PyString_Type'))) + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c', line=26), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c', line=26), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + (struct PyObject *)0 from tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c:27 + +Trace 1: + Transitions: + 'PyString_FromStringAndSize() fails' + 'returning' + Return value: + repr(): ConcreteValue(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c', line=29), value=0) + str(): (struct PyObject *)0 from tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c:29 + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c', line=26), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyString_FromStringAndSize/correct/input.c', line=26), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + RegionForGlobal(gcc.VarDecl('PyExc_MemoryError'))

1 0

[gcc-python-plugin] cpychecker: handle more jumps through function pointers
by David Hugh Malcolm 23 Sep '11

23 Sep '11

commit 703a6d7de55962ee753a387e1787a13da904d056 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Thu Sep 22 19:51:17 2011 -0400 cpychecker: handle more jumps through function pointers libcpychecker/refcounts.py | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index 58a5b30..277e4f4 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -1600,7 +1600,7 @@ class MyState(State): newstate, 'not returning from %s' % stmt.fn)] - if isinstance(stmt.fn, gcc.VarDecl): + if isinstance(stmt.fn, (gcc.VarDecl, gcc.ParmDecl)): # Calling through a function pointer: val = self.eval_rvalue(stmt.fn, stmt.loc) log('val: %s', val)

1 0

[gcc-python-plugin] cpychecker: implement bitwise and, or, xor
by David Hugh Malcolm 23 Sep '11

23 Sep '11

commit 8be72a1334bd1ef708b9e30a9de1acd3854830ae Author: David Malcolm <dmalcolm(a)redhat.com> Date: Thu Sep 22 19:50:30 2011 -0400 cpychecker: implement bitwise and, or, xor libcpychecker/refcounts.py | 27 ++++++++++++++++++++ .../absinterp/arithmetic/correct/input.c | 5 +++ .../absinterp/arithmetic/correct/stdout.txt | 4 +- 3 files changed, 34 insertions(+), 2 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index 5eb40e3..58a5b30 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -1853,6 +1853,33 @@ class MyState(State): a.value // b.value) raise NotImplementedError("Don't know how to cope with division of\n %r\nand\n %rat %s" % (a, b, stmt.loc)) + elif stmt.exprcode == gcc.BitIorExpr: + a, b = self.eval_binop_args(stmt) + if isinstance(a, UnknownValue) or isinstance(b, UnknownValue): + return UnknownValue(stmt.lhs.type, stmt.loc) + if isinstance(a, ConcreteValue) and isinstance(b, ConcreteValue): + return ConcreteValue(stmt.lhs.type, stmt.loc, + a.value | b.value) + raise NotImplementedError("Don't know how to cope with bitwise-or of\n %r\nand\n %rat %s" + % (a, b, stmt.loc)) + elif stmt.exprcode == gcc.BitAndExpr: + a, b = self.eval_binop_args(stmt) + if isinstance(a, UnknownValue) or isinstance(b, UnknownValue): + return UnknownValue(stmt.lhs.type, stmt.loc) + if isinstance(a, ConcreteValue) and isinstance(b, ConcreteValue): + return ConcreteValue(stmt.lhs.type, stmt.loc, + a.value & b.value) + raise NotImplementedError("Don't know how to cope with bitwise-and of\n %r\nand\n %rat %s" + % (a, b, stmt.loc)) + elif stmt.exprcode == gcc.BitXorExpr: + a, b = self.eval_binop_args(stmt) + if isinstance(a, UnknownValue) or isinstance(b, UnknownValue): + return UnknownValue(stmt.lhs.type, stmt.loc) + if isinstance(a, ConcreteValue) and isinstance(b, ConcreteValue): + return ConcreteValue(stmt.lhs.type, stmt.loc, + a.value ^ b.value) + raise NotImplementedError("Don't know how to cope with bitwise-xor of\n %r\nand\n %rat %s" + % (a, b, stmt.loc)) elif stmt.exprcode == gcc.ComponentRef: return self.eval_rvalue(rhs[0], stmt.loc) elif stmt.exprcode == gcc.VarDecl: diff --git a/tests/cpychecker/absinterp/arithmetic/correct/input.c b/tests/cpychecker/absinterp/arithmetic/correct/input.c index eaafa48..5bc319c 100644 --- a/tests/cpychecker/absinterp/arithmetic/correct/input.c +++ b/tests/cpychecker/absinterp/arithmetic/correct/input.c @@ -36,6 +36,11 @@ test(void) foo(i * 2); foo(i / 2); + /* Bitwise: */ + i |= 0xf0f0; + i &= 0xaaaa; + i ^= 0xaaaa; + return i; } diff --git a/tests/cpychecker/absinterp/arithmetic/correct/stdout.txt b/tests/cpychecker/absinterp/arithmetic/correct/stdout.txt index d169037..1d42045 100644 --- a/tests/cpychecker/absinterp/arithmetic/correct/stdout.txt +++ b/tests/cpychecker/absinterp/arithmetic/correct/stdout.txt @@ -2,7 +2,7 @@ Trace 0: Transitions: 'returning' Return value: - repr(): ConcreteValue(gcctype='int', loc=gcc.Location(file='tests/cpychecker/absinterp/arithmetic/correct/input.c', line=35), value=1) - str(): (int)1 from tests/cpychecker/absinterp/arithmetic/correct/input.c:35 + repr(): ConcreteValue(gcctype='int', loc=gcc.Location(file='tests/cpychecker/absinterp/arithmetic/correct/input.c', line=42), value=2570) + str(): (int)2570 from tests/cpychecker/absinterp/arithmetic/correct/input.c:42 Exception: (struct PyObject *)0 from tests/cpychecker/absinterp/arithmetic/correct/input.c:30

1 0

[gcc-python-plugin] cpychecker: implement PyDict_GetItem
by David Hugh Malcolm 23 Sep '11

23 Sep '11

commit 113fe2588086ec26df21255be2223a10d87c679d Author: David Malcolm <dmalcolm(a)redhat.com> Date: Thu Sep 22 19:26:54 2011 -0400 cpychecker: implement PyDict_GetItem libcpychecker/refcounts.py | 14 +++++ .../refcounts/PyDict_GetItem/correct/input.c | 56 ++++++++++++++++++++ .../refcounts/PyDict_GetItem/correct/script.py | 22 ++++++++ .../refcounts/PyDict_GetItem/correct/stdout.txt | 44 +++++++++++++++ .../refcounts/PyDict_GetItem/incorrect/input.c | 49 +++++++++++++++++ .../refcounts/PyDict_GetItem/incorrect/script.py | 22 ++++++++ .../refcounts/PyDict_GetItem/incorrect/stderr.txt | 13 +++++ .../refcounts/PyDict_GetItem/incorrect/stdout.txt | 41 ++++++++++++++ 8 files changed, 261 insertions(+), 0 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index fed6d94..5eb40e3 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -782,6 +782,20 @@ class MyState(State): ######################################################################## # PyDict_* ######################################################################## + def impl_PyDict_GetItem(self, stmt): + # Declared in dictobject.h: + # PyAPI_FUNC(PyObject *) PyDict_GetItem(PyObject *mp, PyObject *key); + # Defined in dictobject.c + # + # Returns a borrowed ref, or NULL if not found. It does _not_ set + # an exception (for historical reasons) + s_success = self.mkstate_borrowed_ref(stmt, 'result from PyDict_GetItem') + t_notfound = self.mktrans_assignment(stmt.lhs, + make_null_pyobject_ptr(stmt), + 'PyDict_GetItem does not find item') + return [self.mktrans_from_fncall_state(stmt, s_success, 'succeeds'), + t_notfound] + def impl_PyDict_GetItemString(self, stmt): # Declared in dictobject.h: # PyAPI_FUNC(PyObject *) PyDict_GetItemString(PyObject *dp, const char *key); diff --git a/tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c b/tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c new file mode 100644 index 0000000..035f861 --- /dev/null +++ b/tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c @@ -0,0 +1,56 @@ +/* + Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> + Copyright 2011 Red Hat, Inc. + + This is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + <http://www.gnu.org/licenses/>. +*/ + +#include <Python.h> + +/* + Test of correct reference-handling in a call to PyDict_GetItem +*/ + +extern PyObject *some_dict; + +PyObject * +test(PyObject *self, PyObject *args) +{ + PyObject *item; + item = PyDict_GetItem(some_dict, args); + if (item) { + /* + If it succeeds, it only returns a borrowed ref, so we must incref + it: + */ + Py_INCREF(item); + return item; + } + PyErr_SetString(PyExc_KeyError, "item not found"); + return NULL; +} + +static PyMethodDef test_methods[] = { + {"test_method", test, METH_VARARGS, NULL}, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/refcounts/PyDict_GetItem/correct/script.py b/tests/cpychecker/refcounts/PyDict_GetItem/correct/script.py new file mode 100644 index 0000000..fdd5ba3 --- /dev/null +++ b/tests/cpychecker/refcounts/PyDict_GetItem/correct/script.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> +# Copyright 2011 Red Hat, Inc. +# +# This is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see +# <http://www.gnu.org/licenses/>. + +from libcpychecker import main +main(verify_refcounting=True, + dump_traces=True, + show_traces=False) diff --git a/tests/cpychecker/refcounts/PyDict_GetItem/correct/stdout.txt b/tests/cpychecker/refcounts/PyDict_GetItem/correct/stdout.txt new file mode 100644 index 0000000..e5212d7 --- /dev/null +++ b/tests/cpychecker/refcounts/PyDict_GetItem/correct/stdout.txt @@ -0,0 +1,44 @@ +Trace 0: + Transitions: + 'PyDict_GetItem() succeeds' + 'taking True path' + 'returning' + Return value: + repr(): PointerToRegion(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c', line=32), region=RegionOnHeap('result from PyDict_GetItem', gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c', line=32))) + str(): (struct PyObject *)&RegionOnHeap('result from PyDict_GetItem', gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c', line=32)) from tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c:32 + r->ob_refcnt: refs: 1 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c', line=32), region=Region('PyTypeObject for result from PyDict_GetItem')) + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + (struct PyObject *)0 from tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c:30 + +Trace 1: + Transitions: + 'PyDict_GetItem does not find item' + 'taking False path' + 'calling PyErr_SetString()' + 'returning' + Return value: + repr(): ConcreteValue(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c', line=42), value=0) + str(): (struct PyObject *)0 from tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c:42 + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/correct/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + unknown struct PyObject * from /usr/include/python2.7/pyerrors.h:135 diff --git a/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c b/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c new file mode 100644 index 0000000..dbbe0a3 --- /dev/null +++ b/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c @@ -0,0 +1,49 @@ +/* + Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> + Copyright 2011 Red Hat, Inc. + + This is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + <http://www.gnu.org/licenses/>. +*/ + +#include <Python.h> + +/* + Test of incorrect reference-handling in a call to PyDict_GetItem +*/ + +extern PyObject *some_dict; + +PyObject * +test(PyObject *self, PyObject *args) +{ + /* + This is incorrect: if the call succeeds, it only returns a borrowed ref, + so this will leave it with too low a reference count: + */ + return PyDict_GetItem(some_dict, args); +} + +static PyMethodDef test_methods[] = { + {"test_method", test, METH_VARARGS, NULL}, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/script.py b/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/script.py new file mode 100644 index 0000000..fdd5ba3 --- /dev/null +++ b/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/script.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> +# Copyright 2011 Red Hat, Inc. +# +# This is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see +# <http://www.gnu.org/licenses/>. + +from libcpychecker import main +main(verify_refcounting=True, + dump_traces=True, + show_traces=False) diff --git a/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/stderr.txt b/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/stderr.txt new file mode 100644 index 0000000..586939c --- /dev/null +++ b/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/stderr.txt @@ -0,0 +1,13 @@ +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c: In function 'test': +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: error: ob_refcnt of return value is 1 too low +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: note: was expecting final ob_refcnt to be N + 1 (for some unknown N) +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: note: due to object being referenced by: return value +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: note: but final ob_refcnt is N + 0 +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: note: result from PyDict_GetItem allocated at: return PyDict_GetItem(some_dict, args); +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: note: when PyDict_GetItem() succeeds at: return PyDict_GetItem(some_dict, args); +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: note: ob_refcnt is now refs: 0 + N where N >= 1 +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: note: when returning at: return PyDict_GetItem(some_dict, args); +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: error: returning (PyObject*)NULL without setting an exception +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: note: when PyDict_GetItem does not find item at: return PyDict_GetItem(some_dict, args); +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35:5: note: when returning at: return PyDict_GetItem(some_dict, args); +tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:30:1: note: graphical error report for function 'test' written out to 'tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c.test-refcount-errors.html' diff --git a/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/stdout.txt b/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/stdout.txt new file mode 100644 index 0000000..3347cdd --- /dev/null +++ b/tests/cpychecker/refcounts/PyDict_GetItem/incorrect/stdout.txt @@ -0,0 +1,41 @@ +Trace 0: + Transitions: + 'PyDict_GetItem() succeeds' + 'returning' + Return value: + repr(): PointerToRegion(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c', line=35), region=RegionOnHeap('result from PyDict_GetItem', gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c', line=35))) + str(): (struct PyObject *)&RegionOnHeap('result from PyDict_GetItem', gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c', line=35)) from tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35 + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c', line=35), region=Region('PyTypeObject for result from PyDict_GetItem')) + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + (struct PyObject *)0 from tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:30 + +Trace 1: + Transitions: + 'PyDict_GetItem does not find item' + 'returning' + Return value: + repr(): ConcreteValue(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c', line=35), value=0) + str(): (struct PyObject *)0 from tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:35 + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + (struct PyObject *)0 from tests/cpychecker/refcounts/PyDict_GetItem/incorrect/input.c:30

1 0

[gcc-python-plugin] cpychecker: implement PyObject_HasAttrString
by David Hugh Malcolm 23 Sep '11

23 Sep '11

commit 88115770ca4379fa3802b8ab04715bbdd36c2f88 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Thu Sep 22 18:52:12 2011 -0400 cpychecker: implement PyObject_HasAttrString libcpychecker/refcounts.py | 23 ++++++++++ .../PyObject_HasAttrString/correct/input.c | 43 +++++++++++++++++++ .../PyObject_HasAttrString/correct/script.py | 22 ++++++++++ .../PyObject_HasAttrString/correct/stdout.txt | 45 ++++++++++++++++++++ .../PyObject_HasAttrString/incorrect/input.c | 42 ++++++++++++++++++ .../PyObject_HasAttrString/incorrect/script.py | 22 ++++++++++ .../PyObject_HasAttrString/incorrect/stderr.txt | 3 + .../PyObject_HasAttrString/incorrect/stdout.txt | 16 +++++++ 8 files changed, 216 insertions(+), 0 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index 57d90f1..fed6d94 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -1262,6 +1262,29 @@ class MyState(State): ######################################################################## # PyObject_* ######################################################################## + def impl_PyObject_HasAttrString(self, stmt): + # http://docs.python.org/c-api/object.html#PyObject_HasAttrString + + fnname = stmt.fn.operand.name + v_o, v_attr_name = self.eval_stmt_args(stmt) + + # the object must be non-NULL: it is unconditionally + # dereferenced to get the ob_type: + self.raise_any_null_ptr_func_arg(stmt, 0, v_o) + + # attr_name must be non-NULL, this fn calls: + # PyObject_GetAttrString(PyObject *v, const char *name) + # which can call: + # PyString_InternFromString(const char *cp) + # PyString_FromString(str) <-- must be non-NULL + self.raise_any_null_ptr_func_arg(stmt, 1, v_attr_name) + + s_true = self.mkstate_concrete_return_of(stmt, 1) + s_false = self.mkstate_concrete_return_of(stmt, 0) + + return [Transition(self, s_true, '%s() returns 1 (true)' % fnname), + Transition(self, s_false, '%s() returns 0 (false)' % fnname)] + def impl_PyObject_IsTrue(self, stmt): # http://docs.python.org/c-api/object.html#PyObject_IsTrue s_true = self.mkstate_concrete_return_of(stmt, 1) diff --git a/tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c b/tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c new file mode 100644 index 0000000..81539b7 --- /dev/null +++ b/tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c @@ -0,0 +1,43 @@ +/* + Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> + Copyright 2011 Red Hat, Inc. + + This is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + <http://www.gnu.org/licenses/>. +*/ + +#include <Python.h> + +/* + Test of correct reference-handling in a call to PyObject_HasAttrString +*/ + +PyObject * +test(PyObject *self, PyObject *args) +{ + int has_name = PyObject_HasAttrString(self, "name"); + return PyBool_FromLong(has_name); +} +static PyMethodDef test_methods[] = { + {"test_method", test, METH_VARARGS, NULL}, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/refcounts/PyObject_HasAttrString/correct/script.py b/tests/cpychecker/refcounts/PyObject_HasAttrString/correct/script.py new file mode 100644 index 0000000..fdd5ba3 --- /dev/null +++ b/tests/cpychecker/refcounts/PyObject_HasAttrString/correct/script.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> +# Copyright 2011 Red Hat, Inc. +# +# This is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see +# <http://www.gnu.org/licenses/>. + +from libcpychecker import main +main(verify_refcounting=True, + dump_traces=True, + show_traces=False) diff --git a/tests/cpychecker/refcounts/PyObject_HasAttrString/correct/stdout.txt b/tests/cpychecker/refcounts/PyObject_HasAttrString/correct/stdout.txt new file mode 100644 index 0000000..5500d6b --- /dev/null +++ b/tests/cpychecker/refcounts/PyObject_HasAttrString/correct/stdout.txt @@ -0,0 +1,45 @@ +Trace 0: + Transitions: + 'PyObject_HasAttrString() returns 1 (true)' + 'PyBool_FromLong() returns' + 'returning' + Return value: + repr(): PointerToRegion(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=30), region=RegionOnHeap('PyBool_FromLong', gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=30))) + str(): (struct PyObject *)&RegionOnHeap('PyBool_FromLong', gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=30)) from tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c:30 + r->ob_refcnt: refs: 1 + N where N >= 0 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=30), region=Region('PyTypeObject for PyBool_FromLong')) + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + (struct PyObject *)0 from tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c:28 + +Trace 1: + Transitions: + 'PyObject_HasAttrString() returns 0 (false)' + 'PyBool_FromLong() returns' + 'returning' + Return value: + repr(): PointerToRegion(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=30), region=RegionOnHeap('PyBool_FromLong', gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=30))) + str(): (struct PyObject *)&RegionOnHeap('PyBool_FromLong', gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=30)) from tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c:30 + r->ob_refcnt: refs: 1 + N where N >= 0 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=30), region=Region('PyTypeObject for PyBool_FromLong')) + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + (struct PyObject *)0 from tests/cpychecker/refcounts/PyObject_HasAttrString/correct/input.c:28 diff --git a/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c b/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c new file mode 100644 index 0000000..27614f6 --- /dev/null +++ b/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c @@ -0,0 +1,42 @@ +/* + Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> + Copyright 2011 Red Hat, Inc. + + This is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + <http://www.gnu.org/licenses/>. +*/ + +#include <Python.h> + +/* + Test of a NULL argument in a call to PyObject_HasAttrString +*/ + +PyObject * +test(PyObject *self, PyObject *args) +{ + return PyBool_FromLong(PyObject_HasAttrString(self, NULL)); +} +static PyMethodDef test_methods[] = { + {"test_method", test, METH_VARARGS, NULL}, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/script.py b/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/script.py new file mode 100644 index 0000000..fdd5ba3 --- /dev/null +++ b/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/script.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> +# Copyright 2011 Red Hat, Inc. +# +# This is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see +# <http://www.gnu.org/licenses/>. + +from libcpychecker import main +main(verify_refcounting=True, + dump_traces=True, + show_traces=False) diff --git a/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/stderr.txt b/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/stderr.txt new file mode 100644 index 0000000..6682ce5 --- /dev/null +++ b/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/stderr.txt @@ -0,0 +1,3 @@ +tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c: In function 'test': +tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c:29:50: error: calling PyObject_HasAttrString with NULL (0B) as argument 1 at tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c:29 +tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c:28:1: note: graphical error report for function 'test' written out to 'tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c.test-refcount-errors.html' diff --git a/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/stdout.txt b/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/stdout.txt new file mode 100644 index 0000000..a274f66 --- /dev/null +++ b/tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/stdout.txt @@ -0,0 +1,16 @@ +Trace 0: + Transitions: + error: NullPtrArgument() + error: calling PyObject_HasAttrString with NULL (0B) as argument 1 at tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c:29 + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + (struct PyObject *)0 from tests/cpychecker/refcounts/PyObject_HasAttrString/incorrect/input.c:28

1 0

[gcc-python-plugin] cpychecker: implement PyTuple_Size
by David Hugh Malcolm 22 Sep '11

22 Sep '11

commit 1e4b12f8d6b4504ac348d11c0adae5faf8067009 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Thu Sep 22 15:24:41 2011 -0400 cpychecker: implement PyTuple_Size libcpychecker/refcounts.py | 39 ++++++++++++ .../refcounts/PyTuple_New/correct/input.c | 4 + .../refcounts/PyTuple_New/correct/stdout.txt | 22 ++++--- .../refcounts/PyTuple_Size/incorrect/input.c | 53 ++++++++++++++++ .../refcounts/PyTuple_Size/incorrect/script.py | 22 +++++++ .../refcounts/PyTuple_Size/incorrect/stderr.txt | 4 + .../refcounts/PyTuple_Size/incorrect/stdout.txt | 63 ++++++++++++++++++++ 7 files changed, 197 insertions(+), 10 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index 8d957f3..57d90f1 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -1474,8 +1474,47 @@ class MyState(State): # PyTuple_* ######################################################################## def impl_PyTuple_New(self, stmt): + # http://docs.python.org/c-api/tuple.html#PyTuple_New + v_len = self.eval_rvalue(stmt.args[0], stmt.loc) + newobj, t_success, t_failure = self.impl_object_ctor(stmt, 'PyTupleObject', 'PyTuple_Type') + # Set ob_size: + r_ob_size = t_success.dest.make_field_region(newobj, 'ob_size') + t_success.dest.value_for_region[r_ob_size] = v_len + return [t_success, t_failure] + + def impl_PyTuple_Size(self, stmt): + # http://docs.python.org/c-api/tuple.html#PyTuple_Size + # Implemented in Objects/tupleobject.c + fnname = 'PyTuple_Size' + returntype = stmt.fn.type.dereference.type + args = self.eval_stmt_args(stmt) + v_op = args[0] + + # The CPython implementation uses PyTuple_Check, which uses + # Py_TYPE(op), an unchecked read through the ptr: + self.raise_any_null_ptr_func_arg(stmt, 0, v_op) + + # FIXME: cast: + v_ob_size = self.get_value_of_field_by_region(v_op.region, + 'ob_size') + t_success = self.mktrans_assignment(stmt.lhs, + v_ob_size, + 'PyTuple_Size() returns ob_size') + + if self.object_ptr_has_global_ob_type(v_op, 'PyTuple_Type'): + # We know it's a PyTupleObject; the call will succeed: + return [t_success] + + # Can fail if not a tuple: + # (For now, ignore the fact that it could be a tuple subclass) + + s_failure = self.mkstate_concrete_return_of(stmt, -1) + s_failure.set_exception('PyExc_SystemError') + t_failure = Transition(self, + s_failure, + '%s() fails (not a tuple)' % fnname) return [t_success, t_failure] ######################################################################## diff --git a/tests/cpychecker/refcounts/PyTuple_New/correct/input.c b/tests/cpychecker/refcounts/PyTuple_New/correct/input.c index bf2bada..df3f848 100644 --- a/tests/cpychecker/refcounts/PyTuple_New/correct/input.c +++ b/tests/cpychecker/refcounts/PyTuple_New/correct/input.c @@ -23,6 +23,8 @@ Test of correct reference-handling in a call to PyTuple_New */ +extern void __cpychecker_dump(Py_ssize_t s); + PyObject * test(PyObject *self, PyObject *args) { @@ -32,6 +34,8 @@ test(PyObject *self, PyObject *args) return NULL; } + __cpychecker_dump(PyTuple_Size(tuple)); + /* "tuple" should now have an ob_refcnt of 1 */ return tuple; } diff --git a/tests/cpychecker/refcounts/PyTuple_New/correct/stdout.txt b/tests/cpychecker/refcounts/PyTuple_New/correct/stdout.txt index b957a57..40fa80d 100644 --- a/tests/cpychecker/refcounts/PyTuple_New/correct/stdout.txt +++ b/tests/cpychecker/refcounts/PyTuple_New/correct/stdout.txt @@ -2,24 +2,26 @@ Trace 0: Transitions: 'PyTuple_New() succeeds' 'taking False path' + 'PyTuple_Size() returns ob_size' + '__dump((Py_ssize_t)0 from tests/cpychecker/refcounts/PyTuple_New/correct/input.c:32)' 'returning' Return value: - repr(): PointerToRegion(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=30), region=RegionOnHeap('PyTupleObject', gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=30))) - str(): (struct PyObject *)&RegionOnHeap('PyTupleObject', gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=30)) from tests/cpychecker/refcounts/PyTuple_New/correct/input.c:30 + repr(): PointerToRegion(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=32), region=RegionOnHeap('PyTupleObject', gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=32))) + str(): (struct PyObject *)&RegionOnHeap('PyTupleObject', gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=32)) from tests/cpychecker/refcounts/PyTuple_New/correct/input.c:32 r->ob_refcnt: refs: 1 + N where N >= 0 - r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=30), region=RegionForGlobal(gcc.VarDecl('PyTuple_Type'))) + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=32), region=RegionForGlobal(gcc.VarDecl('PyTuple_Type'))) Region("region-for-arg-gcc.ParmDecl('self')"): repr(): Region("region-for-arg-gcc.ParmDecl('self')") str(): Region("region-for-arg-gcc.ParmDecl('self')") r->ob_refcnt: refs: 0 + N where N >= 1 - r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) Region("region-for-arg-gcc.ParmDecl('args')"): repr(): Region("region-for-arg-gcc.ParmDecl('args')") str(): Region("region-for-arg-gcc.ParmDecl('args')") r->ob_refcnt: refs: 0 + N where N >= 1 - r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) Exception: - (struct PyObject *)0 from tests/cpychecker/refcounts/PyTuple_New/correct/input.c:28 + (struct PyObject *)0 from tests/cpychecker/refcounts/PyTuple_New/correct/input.c:30 Trace 1: Transitions: @@ -27,17 +29,17 @@ Trace 1: 'taking True path' 'returning' Return value: - repr(): ConcreteValue(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=32), value=0) - str(): (struct PyObject *)0 from tests/cpychecker/refcounts/PyTuple_New/correct/input.c:32 + repr(): ConcreteValue(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=34), value=0) + str(): (struct PyObject *)0 from tests/cpychecker/refcounts/PyTuple_New/correct/input.c:34 Region("region-for-arg-gcc.ParmDecl('self')"): repr(): Region("region-for-arg-gcc.ParmDecl('self')") str(): Region("region-for-arg-gcc.ParmDecl('self')") r->ob_refcnt: refs: 0 + N where N >= 1 - r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) Region("region-for-arg-gcc.ParmDecl('args')"): repr(): Region("region-for-arg-gcc.ParmDecl('args')") str(): Region("region-for-arg-gcc.ParmDecl('args')") r->ob_refcnt: refs: 0 + N where N >= 1 - r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_New/correct/input.c', line=29), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) Exception: RegionForGlobal(gcc.VarDecl('PyExc_MemoryError')) diff --git a/tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c b/tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c new file mode 100644 index 0000000..eb4d63a --- /dev/null +++ b/tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c @@ -0,0 +1,53 @@ +/* + Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> + Copyright 2011 Red Hat, Inc. + + This is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + <http://www.gnu.org/licenses/>. +*/ + +#include <Python.h> + +/* + Test of incorrect call to PyTuple_Size +*/ + +PyObject * +test(PyObject *self, PyObject *args) +{ + PyObject *dict; + dict = PyDict_New(); + + /* + This can go wrong in two ways: + - if the allocation failed, then we have a read through NULL + - it the allocation succeeded, it's a dict, not a tuple + */ + PyTuple_Size(dict); + + /* "dict" should either be NULL or have an ob_refcnt of 1 */ + return dict; +} +static PyMethodDef test_methods[] = { + {"test_method", test, METH_VARARGS, NULL}, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/refcounts/PyTuple_Size/incorrect/script.py b/tests/cpychecker/refcounts/PyTuple_Size/incorrect/script.py new file mode 100644 index 0000000..fdd5ba3 --- /dev/null +++ b/tests/cpychecker/refcounts/PyTuple_Size/incorrect/script.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> +# Copyright 2011 Red Hat, Inc. +# +# This is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see +# <http://www.gnu.org/licenses/>. + +from libcpychecker import main +main(verify_refcounting=True, + dump_traces=True, + show_traces=False) diff --git a/tests/cpychecker/refcounts/PyTuple_Size/incorrect/stderr.txt b/tests/cpychecker/refcounts/PyTuple_Size/incorrect/stderr.txt new file mode 100644 index 0000000..e151fcd --- /dev/null +++ b/tests/cpychecker/refcounts/PyTuple_Size/incorrect/stderr.txt @@ -0,0 +1,4 @@ +tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c: In function 'test': +tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c:37:17: error: calling PyTuple_Size with NULL (gcc.VarDecl('dict')) as argument 0 at tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c:37 +tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c:30:10: note: when PyDict_New() fails at: dict = PyDict_New(); +tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c:28:1: note: graphical error report for function 'test' written out to 'tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c.test-refcount-errors.html' diff --git a/tests/cpychecker/refcounts/PyTuple_Size/incorrect/stdout.txt b/tests/cpychecker/refcounts/PyTuple_Size/incorrect/stdout.txt new file mode 100644 index 0000000..5bdf49d --- /dev/null +++ b/tests/cpychecker/refcounts/PyTuple_Size/incorrect/stdout.txt @@ -0,0 +1,63 @@ +Trace 0: + Transitions: + 'PyDict_New() succeeds' + 'PyTuple_Size() returns ob_size' + 'returning' + Return value: + repr(): PointerToRegion(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=30), region=RegionOnHeap('PyDictObject', gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=30))) + str(): (struct PyObject *)&RegionOnHeap('PyDictObject', gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=30)) from tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c:30 + r->ob_refcnt: refs: 1 + N where N >= 0 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=30), region=RegionForGlobal(gcc.VarDecl('PyDict_Type'))) + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + (struct PyObject *)0 from tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c:28 + +Trace 1: + Transitions: + 'PyDict_New() succeeds' + 'PyTuple_Size() fails (not a tuple)' + 'returning' + Return value: + repr(): PointerToRegion(gcctype='struct PyObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=30), region=RegionOnHeap('PyDictObject', gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=30))) + str(): (struct PyObject *)&RegionOnHeap('PyDictObject', gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=30)) from tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c:30 + r->ob_refcnt: refs: 1 + N where N >= 0 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=30), region=RegionForGlobal(gcc.VarDecl('PyDict_Type'))) + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + RegionForGlobal(gcc.VarDecl('PyExc_SystemError')) + +Trace 2: + Transitions: + 'PyDict_New() fails' + error: NullPtrArgument() + error: calling PyTuple_Size with NULL (gcc.VarDecl('dict')) as argument 0 at tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c:37 + Region("region-for-arg-gcc.ParmDecl('self')"): + repr(): Region("region-for-arg-gcc.ParmDecl('self')") + str(): Region("region-for-arg-gcc.ParmDecl('self')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('self')")) + Region("region-for-arg-gcc.ParmDecl('args')"): + repr(): Region("region-for-arg-gcc.ParmDecl('args')") + str(): Region("region-for-arg-gcc.ParmDecl('args')") + r->ob_refcnt: refs: 0 + N where N >= 1 + r->ob_type: PointerToRegion(gcctype='struct PyTypeObject *', loc=gcc.Location(file='tests/cpychecker/refcounts/PyTuple_Size/incorrect/input.c', line=27), region=Region("region-for-type-of-arg-gcc.ParmDecl('args')")) + Exception: + RegionForGlobal(gcc.VarDecl('PyExc_MemoryError'))

1 0

[gcc-python-plugin] cpychecker: implement division
by David Hugh Malcolm 21 Sep '11

21 Sep '11

commit fa7b4c4b8f076a6add45cdbc77f490f4a5023b43 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Wed Sep 21 14:18:47 2011 -0400 cpychecker: implement division libcpychecker/refcounts.py | 33 ++++++++++++------- .../absinterp/arithmetic/correct/input.c | 2 + 2 files changed, 23 insertions(+), 12 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index 5ab617c..8d957f3 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -1724,14 +1724,20 @@ class MyState(State): # % (exprcode, lhs, rhs)) return UnknownValue(stmt.lhs.type, stmt.loc) + def eval_binop_args(self, stmt): + rhs = stmt.rhs + a = self.eval_rvalue(rhs[0], stmt.loc) + b = self.eval_rvalue(rhs[1], stmt.loc) + log('a: %r', a) + log('b: %r', b) + return a, b + def eval_rhs(self, stmt): log('eval_rhs(%s): %s', stmt, stmt.rhs) rhs = stmt.rhs + # Handle arithmetic expressions: if stmt.exprcode == gcc.PlusExpr: - a = self.eval_rvalue(rhs[0], stmt.loc) - b = self.eval_rvalue(rhs[1], stmt.loc) - log('a: %r', a) - log('b: %r', b) + a, b = self.eval_binop_args(stmt) if isinstance(a, UnknownValue) or isinstance(b, UnknownValue): return UnknownValue(stmt.lhs.type, stmt.loc) if isinstance(a, ConcreteValue) and isinstance(b, ConcreteValue): @@ -1744,10 +1750,7 @@ class MyState(State): raise NotImplementedError("Don't know how to cope with addition of\n %r\nand\n %r\nat %s" % (a, b, stmt.loc)) elif stmt.exprcode == gcc.MinusExpr: - a = self.eval_rvalue(rhs[0], stmt.loc) - b = self.eval_rvalue(rhs[1], stmt.loc) - log('a: %r', a) - log('b: %r', b) + a, b = self.eval_binop_args(stmt) if isinstance(a, UnknownValue) or isinstance(b, UnknownValue): return UnknownValue(stmt.lhs.type, stmt.loc) if isinstance(a, ConcreteValue) and isinstance(b, ConcreteValue): @@ -1758,16 +1761,22 @@ class MyState(State): raise NotImplementedError("Don't know how to cope with subtraction of\n %r\nand\n %rat %s" % (a, b, stmt.loc)) elif stmt.exprcode == gcc.MultExpr: - a = self.eval_rvalue(rhs[0], stmt.loc) - b = self.eval_rvalue(rhs[1], stmt.loc) - log('a: %r', a) - log('b: %r', b) + a, b = self.eval_binop_args(stmt) if isinstance(a, UnknownValue) or isinstance(b, UnknownValue): return UnknownValue(stmt.lhs.type, stmt.loc) if isinstance(a, ConcreteValue) and isinstance(b, ConcreteValue): return ConcreteValue(stmt.lhs.type, stmt.loc, a.value * b.value) raise NotImplementedError("Don't know how to cope with multiplication of\n %r\nand\n %rat %s" % (a, b, stmt.loc)) + elif stmt.exprcode == gcc.TruncDivExpr: + a, b = self.eval_binop_args(stmt) + if isinstance(a, UnknownValue) or isinstance(b, UnknownValue): + return UnknownValue(stmt.lhs.type, stmt.loc) + if isinstance(a, ConcreteValue) and isinstance(b, ConcreteValue): + return ConcreteValue(stmt.lhs.type, stmt.loc, + a.value // b.value) + raise NotImplementedError("Don't know how to cope with division of\n %r\nand\n %rat %s" + % (a, b, stmt.loc)) elif stmt.exprcode == gcc.ComponentRef: return self.eval_rvalue(rhs[0], stmt.loc) elif stmt.exprcode == gcc.VarDecl: diff --git a/tests/cpychecker/absinterp/arithmetic/correct/input.c b/tests/cpychecker/absinterp/arithmetic/correct/input.c index 9da7555..eaafa48 100644 --- a/tests/cpychecker/absinterp/arithmetic/correct/input.c +++ b/tests/cpychecker/absinterp/arithmetic/correct/input.c @@ -33,6 +33,8 @@ test(void) foo(i++); foo(i++); foo(i--); + foo(i * 2); + foo(i / 2); return i; }

1 0

[gcc-python-plugin] cpychecker: fix subtraction
by David Hugh Malcolm 21 Sep '11

21 Sep '11

commit 7d5483b0e310e6d1c1a46d0e54109487d7ee5e2e Author: David Malcolm <dmalcolm(a)redhat.com> Date: Tue Sep 20 19:51:43 2011 -0400 cpychecker: fix subtraction libcpychecker/refcounts.py | 3 + .../absinterp/arithmetic/correct/input.c | 46 ++++++++++++++++++++ .../absinterp/arithmetic/correct/script.py | 22 +++++++++ .../absinterp/arithmetic/correct/stdout.txt | 8 +++ 4 files changed, 79 insertions(+), 0 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index 76dc65b..5ab617c 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -1750,6 +1750,9 @@ class MyState(State): log('b: %r', b) if isinstance(a, UnknownValue) or isinstance(b, UnknownValue): return UnknownValue(stmt.lhs.type, stmt.loc) + if isinstance(a, ConcreteValue) and isinstance(b, ConcreteValue): + return ConcreteValue(stmt.lhs.type, stmt.loc, + a.value - b.value) if isinstance(a, RefcountValue) and isinstance(b, ConcreteValue): return RefcountValue(a.relvalue - b.value, a.min_external) raise NotImplementedError("Don't know how to cope with subtraction of\n %r\nand\n %rat %s" diff --git a/tests/cpychecker/absinterp/arithmetic/correct/input.c b/tests/cpychecker/absinterp/arithmetic/correct/input.c new file mode 100644 index 0000000..9da7555 --- /dev/null +++ b/tests/cpychecker/absinterp/arithmetic/correct/input.c @@ -0,0 +1,46 @@ +/* + Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> + Copyright 2011 Red Hat, Inc. + + This is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + <http://www.gnu.org/licenses/>. +*/ + +#include <Python.h> + +/* + Test of various arithmetic operations +*/ + +extern void foo(int); + +int +test(void) +{ + int i = 0; + + foo(i++); + foo(i++); + foo(i--); + + return i; +} + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/absinterp/arithmetic/correct/script.py b/tests/cpychecker/absinterp/arithmetic/correct/script.py new file mode 100644 index 0000000..fdd5ba3 --- /dev/null +++ b/tests/cpychecker/absinterp/arithmetic/correct/script.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> +# Copyright 2011 Red Hat, Inc. +# +# This is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see +# <http://www.gnu.org/licenses/>. + +from libcpychecker import main +main(verify_refcounting=True, + dump_traces=True, + show_traces=False) diff --git a/tests/cpychecker/absinterp/arithmetic/correct/stdout.txt b/tests/cpychecker/absinterp/arithmetic/correct/stdout.txt new file mode 100644 index 0000000..d169037 --- /dev/null +++ b/tests/cpychecker/absinterp/arithmetic/correct/stdout.txt @@ -0,0 +1,8 @@ +Trace 0: + Transitions: + 'returning' + Return value: + repr(): ConcreteValue(gcctype='int', loc=gcc.Location(file='tests/cpychecker/absinterp/arithmetic/correct/input.c', line=35), value=1) + str(): (int)1 from tests/cpychecker/absinterp/arithmetic/correct/input.c:35 + Exception: + (struct PyObject *)0 from tests/cpychecker/absinterp/arithmetic/correct/input.c:30

1 0

[gcc-python-plugin] cpychecker: add initial implementation of type conversions (aka casts)
by David Hugh Malcolm 21 Sep '11

21 Sep '11

commit bb060449267f461afc67d821b1ec23fd886b4bee Author: David Malcolm <dmalcolm(a)redhat.com> Date: Tue Sep 20 19:14:06 2011 -0400 cpychecker: add initial implementation of type conversions (aka casts) libcpychecker/refcounts.py | 12 ++++++ .../absinterp/casts/pointer-to-long/input.c | 38 ++++++++++++++++++++ .../absinterp/casts/pointer-to-long/script.py | 22 +++++++++++ .../absinterp/casts/pointer-to-long/stdout.txt | 8 ++++ 4 files changed, 80 insertions(+), 0 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index c8f7a11..76dc65b 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -1796,6 +1796,18 @@ class MyState(State): 1 if result else 0) else: return UnknownValue(stmt.lhs.type, stmt.loc) + elif stmt.exprcode == gcc.ConvertExpr: + # Type-conversions (e.g. casts) + # Seems to just involve stmt.lhs.type and stmt.rhs[0].type + # (and the lvalue/rvalue) + rvalue = self.eval_rvalue(stmt.rhs[0], stmt.loc) + if isinstance(rvalue, UnknownValue): + # Update the type to that of the lhs: + return UnknownValue(stmt.lhs.type, + stmt.loc) + else: + raise NotImplementedError("Don't know how to cope with type conversion of: %r (%s) at %s to type %s" + % (rvalue, rvalue, stmt.loc, stmt.lhs.type)) else: raise NotImplementedError("Don't know how to cope with exprcode: %r (%s) at %s" % (stmt.exprcode, stmt.exprcode, stmt.loc)) diff --git a/tests/cpychecker/absinterp/casts/pointer-to-long/input.c b/tests/cpychecker/absinterp/casts/pointer-to-long/input.c new file mode 100644 index 0000000..288b68b --- /dev/null +++ b/tests/cpychecker/absinterp/casts/pointer-to-long/input.c @@ -0,0 +1,38 @@ +/* + Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> + Copyright 2011 Red Hat, Inc. + + This is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + <http://www.gnu.org/licenses/>. +*/ + +#include <Python.h> + +/* + Test of casting from a pointer to a long +*/ + +long +test(void *ptr) +{ + return (long)ptr; +} + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/absinterp/casts/pointer-to-long/script.py b/tests/cpychecker/absinterp/casts/pointer-to-long/script.py new file mode 100644 index 0000000..fdd5ba3 --- /dev/null +++ b/tests/cpychecker/absinterp/casts/pointer-to-long/script.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2011 David Malcolm <dmalcolm(a)redhat.com> +# Copyright 2011 Red Hat, Inc. +# +# This is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see +# <http://www.gnu.org/licenses/>. + +from libcpychecker import main +main(verify_refcounting=True, + dump_traces=True, + show_traces=False) diff --git a/tests/cpychecker/absinterp/casts/pointer-to-long/stdout.txt b/tests/cpychecker/absinterp/casts/pointer-to-long/stdout.txt new file mode 100644 index 0000000..942958d --- /dev/null +++ b/tests/cpychecker/absinterp/casts/pointer-to-long/stdout.txt @@ -0,0 +1,8 @@ +Trace 0: + Transitions: + 'returning' + Return value: + repr(): UnknownValue(gcctype=<gcc.IntegerType object at 0xdeadbeef>, loc=gcc.Location(file='tests/cpychecker/absinterp/casts/pointer-to-long/input.c', line=29)) + str(): unknown long int from tests/cpychecker/absinterp/casts/pointer-to-long/input.c:29 + Exception: + (struct PyObject *)0 from tests/cpychecker/absinterp/casts/pointer-to-long/input.c:28

1 0

[gcc-python-plugin] specfile: add pygments to build-time requirements
by David Hugh Malcolm 19 Sep '11

19 Sep '11

commit da31b8864600638000d5be68d387e46d2c592958 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Mon Sep 19 17:07:36 2011 -0400 specfile: add pygments to build-time requirements gcc-python-plugin.spec | 4 ++++ 1 files changed, 4 insertions(+), 0 deletions(-) --- diff --git a/gcc-python-plugin.spec b/gcc-python-plugin.spec index de3021b..3a64249 100644 --- a/gcc-python-plugin.spec +++ b/gcc-python-plugin.spec @@ -31,6 +31,10 @@ BuildRequires: python3-six # sphinx is used for building documentation: BuildRequires: python-sphinx +# pygments is used when running the selftests: +BuildRequires: python-pygments +BuildRequires: python3-pygments + %global gcc_plugins_dir %(gcc --print-file-name=plugin) %description

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

gcc-python-plugin-commits September 2011