gcc-python-plugin-commits June 2011

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

2 participants
53 discussions

[gcc-python-plugin] Add 'arguments' and 'result' to gcc.FunctionDecl
by David Hugh Malcolm 27 Jun '11

27 Jun '11

commit 513007398f56abce9959a47f941afcc1d6cefe13 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Mon Jun 27 05:42:25 2011 -0400 Add 'arguments' and 'result' to gcc.FunctionDecl docs/cfg.rst | 12 ++++++++---- docs/tree.rst | 12 +++++++++++- generate-tree-c.py | 6 ++++++ tests/plugin/functions/script.py | 10 ++++++++++ tests/plugin/functions/stdout.txt | 9 +++++++++ 5 files changed, 44 insertions(+), 5 deletions(-) --- diff --git a/docs/cfg.rst b/docs/cfg.rst index 0212399..b0b745b 100644 --- a/docs/cfg.rst +++ b/docs/cfg.rst @@ -42,10 +42,14 @@ You can get at the control flow graph of a :py:class:`gcc.Function` via its .. py:attribute:: local_decls - List of :py:class:`gcc.VarDecl` for the function's local variables. Note - that `initial` only seems to get set on these for static variables. For - other locals, it appears that you have to go into the gimple - representation to locate assignments. + List of :py:class:`gcc.VarDecl` for the function's local variables. It + does not contain arguments; for those see the `arguments` property of + the function's `decl`. + + Note that for locals with initializers, `initial` only seems to get set + on those `local_decls` that are static variables. For other locals, it + appears that you have to go into the gimple representation to locate + assignments. .. py:attribute:: start diff --git a/docs/tree.rst b/docs/tree.rst index 8793ac6..15679c7 100644 --- a/docs/tree.rst +++ b/docs/tree.rst @@ -166,7 +166,7 @@ Declarations The :py:class:`gcc.Location` for this declaration -.. py:class:: gcc.FuncDecl +.. py:class:: gcc.FunctionDecl A subclass of `gcc.Declaration` indicating the declaration of a function. Internally, this wraps a `(struct tree_function_decl *)` @@ -175,6 +175,16 @@ Declarations The :py:class:`gcc.Function` for this declaration + .. py:attribute:: arguments + + List of :py:class:`gcc.ParmDecl` representing the arguments of this + function + + .. py:attribute:: result + + The :py:class:`gcc.ResultDecl` representing the return value of this + function + .. Declaration .. ClassMethodDecl .. ConstDecl diff --git a/generate-tree-c.py b/generate-tree-c.py index ba1bb1e..419aaaa 100644 --- a/generate-tree-c.py +++ b/generate-tree-c.py @@ -407,6 +407,12 @@ def generate_tree_code_classes(): add_simple_getter('function', 'gcc_python_make_wrapper_function(DECL_STRUCT_FUNCTION(self->t))', 'The gcc.Function (or None) for this declaration') + add_simple_getter('arguments', + 'gcc_tree_list_from_chain(DECL_ARGUMENTS(self->t))', + 'List of gcc.ParmDecl') + add_simple_getter('result', + 'gcc_python_make_wrapper_tree(DECL_RESULT_FLD(self->t))', + 'The gcc.ResultDecl for the return value') if tree_type.SYM == 'SSA_NAME': # c.f. "struct GTY(()) tree_ssa_name": diff --git a/tests/plugin/functions/script.py b/tests/plugin/functions/script.py index c7c9123..a6d7b4c 100644 --- a/tests/plugin/functions/script.py +++ b/tests/plugin/functions/script.py @@ -68,5 +68,15 @@ def on_pass_execution(p, fn): #print(dir(stmt)) #pprint(stmt) + + print('fn.decl.arguments: %r' % fn.decl.arguments) + for i, arg in enumerate(fn.decl.arguments): + print(' arg[%i]:' % i) + print(' arg.name: %r' % arg.name) + print(' str(arg.type): %r' % str(arg.type)) + print('type(fn.decl.result): %r' % type(fn.decl.result)) + print(' str(fn.decl.result.type): %r' % str(fn.decl.result.type)) + + gcc.register_callback(gcc.PLUGIN_PASS_EXECUTION, on_pass_execution) diff --git a/tests/plugin/functions/stdout.txt b/tests/plugin/functions/stdout.txt index ab04eb0..067395e 100644 --- a/tests/plugin/functions/stdout.txt +++ b/tests/plugin/functions/stdout.txt @@ -57,3 +57,12 @@ gimple[3]: gimple[4]: str(stmt): 'return;' repr(stmt): 'gcc.GimpleReturn()' +fn.decl.arguments: [gcc.ParmDecl('a'), gcc.ParmDecl('b')] + arg[0]: + arg.name: 'a' + str(arg.type): 'int' + arg[1]: + arg.name: 'b' + str(arg.type): 'int' +type(fn.decl.result): <type 'gcc.ResultDecl'> + str(fn.decl.result.type): 'void'

1 0

[gcc-python-plugin] Add 'local_decls', 'start', 'end', 'funcdef_no' to gcc.Function
by David Hugh Malcolm 27 Jun '11

27 Jun '11

commit 644eab60ba23078b3b8297bd7d0b767d473ff5da Author: David Malcolm <dmalcolm(a)redhat.com> Date: Mon Jun 27 04:49:50 2011 -0400 Add 'local_decls', 'start', 'end', 'funcdef_no' to gcc.Function docs/cfg.rst | 21 ++++++++++- generate-function-c.py | 18 +++++++++- tests/plugin/functions/input.c | 40 ++++++++++++++++++++ tests/plugin/functions/script.py | 72 +++++++++++++++++++++++++++++++++++++ tests/plugin/functions/stdout.txt | 59 ++++++++++++++++++++++++++++++ 5 files changed, 208 insertions(+), 2 deletions(-) --- diff --git a/docs/cfg.rst b/docs/cfg.rst index b5deaf5..0212399 100644 --- a/docs/cfg.rst +++ b/docs/cfg.rst @@ -38,7 +38,26 @@ You can get at the control flow graph of a :py:class:`gcc.Function` via its .. py:attribute:: decl - The declaration of this function, as a :py:class:`gcc.Tree` + The declaration of this function, as a :py:class:`gcc.FunctionDecl` + + .. py:attribute:: local_decls + + List of :py:class:`gcc.VarDecl` for the function's local variables. Note + that `initial` only seems to get set on these for static variables. For + other locals, it appears that you have to go into the gimple + representation to locate assignments. + + .. py:attribute:: start + + The :py:class:`gcc.Location` of the beginning of the function + + .. py:attribute:: end + + The :py:class:`gcc.Location` of the end of the function + + .. py:attribute:: funcdef_no + + Integer: a sequence number for profiling, debugging, etc. .. py:class:: gcc.Cfg diff --git a/generate-function-c.py b/generate-function-c.py index 0ebb3f8..e62231e 100644 --- a/generate-function-c.py +++ b/generate-function-c.py @@ -48,7 +48,23 @@ def generate_function(): getsettable.add_simple_getter(cu, 'decl', 'gcc_python_make_wrapper_tree(self->fun->decl)', - 'The declaration of this function, as a gcc.Tree instance') + 'The declaration of this function, as a gcc.FunctionDecl instance') + getsettable.add_simple_getter(cu, + 'local_decls', + 'VEC_tree_as_PyList(self->fun->local_decls)', + "List of gcc.VarDecl for the function's local variables") + getsettable.add_simple_getter(cu, + 'funcdef_no', + 'gcc_python_int_from_long(self->fun->funcdef_no)', + 'Function sequence number for profiling, debugging, etc.') + getsettable.add_simple_getter(cu, + 'start', + 'gcc_python_make_wrapper_location(self->fun->function_start_locus)', + 'Location of the start of the function') + getsettable.add_simple_getter(cu, + 'end', + 'gcc_python_make_wrapper_location(self->fun->function_end_locus)', + 'Location of the end of the function') cu.add_defn(getsettable.c_defn()) pytype = PyTypeObject(identifier = 'gcc_FunctionType', diff --git a/tests/plugin/functions/input.c b/tests/plugin/functions/input.c new file mode 100644 index 0000000..9196fff --- /dev/null +++ b/tests/plugin/functions/input.c @@ -0,0 +1,40 @@ +/* + 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 <stdio.h> + +void foo(int a, int b) +{ + float f, g; + float h = 1.0f; + static int i = 42; + char *keywords[] = {"bar", NULL}; + const double d = 2.0; + + /* empty */ +} + + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/plugin/functions/script.py b/tests/plugin/functions/script.py new file mode 100644 index 0000000..c7c9123 --- /dev/null +++ b/tests/plugin/functions/script.py @@ -0,0 +1,72 @@ +# 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/>. + +# Verify examining details of functions + +import gcc +from gccutils import pprint + +def on_pass_execution(p, fn): + if p.name == '*warn_function_return': + assert isinstance(fn, gcc.Function) + print('fn: %r' % fn) + + assert isinstance(fn.decl, gcc.FunctionDecl) + print('fn.decl.name: %r' % fn.decl.name) + + assert isinstance(fn.decl, gcc.FunctionDecl) + #print(fn.decl.type) + #print(fn.decl.type.argument_types) + #pprint(fn.decl) + + print('len(fn.local_decls): %r' % len(fn.local_decls)) + for i, local in enumerate(fn.local_decls): + print('local_decls[%i]' % i) + print(' type(local): %r' % type(local)) + print(' local.name: %r' % local.name) + # The "initial" only seems to be present for static variables + # with initializers. Other variables seem to get initialized + # in explicit gimple statements (see below) + if local.initial: + print(' local.initial.constant: %r' % local.initial.constant) + else: + print(' local.initial: %r' % local.initial) + print(' str(local.type): %r' % str(local.type)) + #pprint(local) + #local.debug() + + print('fn.funcdef_no: %r' % fn.funcdef_no) + print('fn.start: %r' % fn.start) + print('fn.end: %r' % fn.end) + + assert isinstance(fn.cfg, gcc.Cfg) # None for some early passes + assert len(fn.cfg.basic_blocks) == 3 + assert fn.cfg.basic_blocks[0] == fn.cfg.entry + assert fn.cfg.basic_blocks[1] == fn.cfg.exit + bb = fn.cfg.basic_blocks[2] + for i,stmt in enumerate(bb.gimple): + print 'gimple[%i]:' % i + print ' str(stmt): %r' % str(stmt) + print ' repr(stmt): %r' % repr(stmt) + if isinstance(stmt, gcc.GimpleAssign): + print(' str(stmt.lhs): %r' % str(stmt.lhs)) + print(' [str(stmt.rhs)]: %r' % [str(item) for item in stmt.rhs]) + #print(dir(stmt)) + #pprint(stmt) + +gcc.register_callback(gcc.PLUGIN_PASS_EXECUTION, + on_pass_execution) diff --git a/tests/plugin/functions/stdout.txt b/tests/plugin/functions/stdout.txt new file mode 100644 index 0000000..ab04eb0 --- /dev/null +++ b/tests/plugin/functions/stdout.txt @@ -0,0 +1,59 @@ +fn: gcc.Function('foo') +fn.decl.name: 'foo' +len(fn.local_decls): 6 +local_decls[0] + type(local): <type 'gcc.VarDecl'> + local.name: 'f' + local.initial: None + str(local.type): 'float' +local_decls[1] + type(local): <type 'gcc.VarDecl'> + local.name: 'g' + local.initial: None + str(local.type): 'float' +local_decls[2] + type(local): <type 'gcc.VarDecl'> + local.name: 'h' + local.initial: None + str(local.type): 'float' +local_decls[3] + type(local): <type 'gcc.VarDecl'> + local.name: 'i' + local.initial.constant: 42L + str(local.type): 'int' +local_decls[4] + type(local): <type 'gcc.VarDecl'> + local.name: 'keywords' + local.initial: None + str(local.type): 'char *[2]' +local_decls[5] + type(local): <type 'gcc.VarDecl'> + local.name: 'd' + local.initial: None + str(local.type): 'const double' +fn.funcdef_no: 0 +fn.start: gcc.Location(file='tests/plugin/functions/input.c', line=23) +fn.end: gcc.Location(file='tests/plugin/functions/input.c', line=31) +gimple[0]: + str(stmt): 'h = 1.0e+0;' + repr(stmt): 'gcc.GimpleAssign()' + str(stmt.lhs): "gcc.VarDecl('h')" + [str(stmt.rhs)]: ['1.0e+0'] +gimple[1]: + str(stmt): 'keywords[0] = "bar";' + repr(stmt): 'gcc.GimpleAssign()' + str(stmt.lhs): 'keywords[0]' + [str(stmt.rhs)]: ['"bar"'] +gimple[2]: + str(stmt): 'keywords[1] = 0B;' + repr(stmt): 'gcc.GimpleAssign()' + str(stmt.lhs): 'keywords[1]' + [str(stmt.rhs)]: ['0B'] +gimple[3]: + str(stmt): 'd = 2.0e+0;' + repr(stmt): 'gcc.GimpleAssign()' + str(stmt.lhs): "gcc.VarDecl('d')" + [str(stmt.rhs)]: ['2.0e+0'] +gimple[4]: + str(stmt): 'return;' + repr(stmt): 'gcc.GimpleReturn()'

1 0

[gcc-python-plugin] Remove redundant (and non-functioning) selftest for "O&" format code
by David Hugh Malcolm 25 Jun '11

25 Jun '11

commit 6c1e276c729f48ab0bdae2645b2c5e45e2c27cb4 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Sat Jun 25 11:52:46 2011 -0400 Remove redundant (and non-functioning) selftest for "O&" format code testcpychecker.py | 18 +++--------------- 1 files changed, 3 insertions(+), 15 deletions(-) --- diff --git a/testcpychecker.py b/testcpychecker.py index 3a00576..2966f90 100644 --- a/testcpychecker.py +++ b/testcpychecker.py @@ -370,21 +370,9 @@ correct_usage(PyObject *self, PyObject *args) def test_format_code_O_bang(self): self._test_format_code('O!', ['PyTypeObject', 'PyObject *']) - def test_format_code_O_amp(self): - # O& (object) [converter, anything] - # Converter should be a function of the form: - # int conv(object, T* val_addr) - # args should be: converter, T* - src = self.make_src_for_correct_function('O&', ['int'], - params='my_converter, &val0') - src = 'extern int my_converter(PyObject *obj, int *i);\n\n' + src - # self.assertNoErrors(src) - - #self._test_format_code('O&', ['PyTypeObject', 'PyObject *']) - #self.assert_args("O&", - # ['int ( PyObject * object , int * target )', - # 'int *', - # 'int *']) + # Code "O&" is tested by: + # tests/cpychecker/PyArg_ParseTuple/correct_converter/ + # tests/cpychecker/PyArg_ParseTuple/incorrect_converters/ # Codes "S" and "U" require some special treatment, as they can support # multiple types. We tests them via these selftests:

1 0

[gcc-python-plugin] Add the example from my blog post ( http://dmalcolm.livejournal.com/6364.html )
by David Hugh Malcolm 25 Jun '11

25 Jun '11

commit d802fe068f0a40c58457df0e9f2c253b0282f053 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Sat Jun 25 10:26:58 2011 -0400 Add the example from my blog post ( http://dmalcolm.livejournal.com/6364.html ) Makefile | 2 +- demo.c | 15 +++++++++++++++ 2 files changed, 16 insertions(+), 1 deletions(-) --- diff --git a/Makefile b/Makefile index 39d5a61..d881808 100644 --- a/Makefile +++ b/Makefile @@ -122,7 +122,7 @@ debug: plugin # A simple demo, to make it easy to demonstrate the cpychecker: demo: plugin - gcc -fplugin=$(shell pwd)/python.so -fplugin-arg-python-script=cpychecker.py $(shell python-config --cflags) $(shell pwd)/demo.c + gcc -fplugin=$(shell pwd)/python.so -fplugin-arg-python-script=cpychecker.py $(shell python-config --cflags) demo.c test-suite: plugin python run-test-suite.py diff --git a/demo.c b/demo.c index 5d4dc01..5499305 100644 --- a/demo.c +++ b/demo.c @@ -65,6 +65,21 @@ kwargs_example(PyObject *self, PyObject *args, PyObject *kwargs) Py_RETURN_NONE; } + +extern int convert_to_ssize(PyObject *, Py_ssize_t *); + +PyObject * +buggy_converter(PyObject *self, PyObject *args) +{ + int i; + + if (!PyArg_ParseTuple(args, "O&", convert_to_ssize, &i)) { + return NULL; + } + + Py_RETURN_NONE; +} + /* PEP-7 Local variables:

1 0

[gcc-python-plugin] Use newlines and indentation to try to make the PyArg_ error messages more readable
by David Hugh Malcolm 24 Jun '11

24 Jun '11

commit 63ea6c0548da9869b15b87f41abf47bb4ec6f791 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Fri Jun 24 20:01:29 2011 -0400 Use newlines and indentation to try to make the PyArg_ error messages more readable libcpychecker/PyArg_ParseTuple.py | 29 ++++++--- testcpychecker.py | 27 ++++++-- .../incorrect_code_z_hash/stderr.txt | 7 ++- .../incorrect_codes_S_and_U/stderr.txt | 14 +++- .../incorrect_converters/stderr.txt | 71 +++++++++++++++----- 5 files changed, 109 insertions(+), 39 deletions(-) --- diff --git a/libcpychecker/PyArg_ParseTuple.py b/libcpychecker/PyArg_ParseTuple.py index f0b0687..bf99e35 100644 --- a/libcpychecker/PyArg_ParseTuple.py +++ b/libcpychecker/PyArg_ParseTuple.py @@ -416,13 +416,21 @@ class WrongNumberOfVars(ParsedFormatStringError): self.varargs = varargs def __str__(self): - return '%s in call to %s with format string "%s" : expected %i extra arguments (%s), but got %i' % ( - self._get_desc_prefix(), - self.funcname, - self.fmt.fmt_string, - self.fmt.num_expected(), - ', '.join([describe_type(exp_type) for (arg, exp_type) in self.fmt.iter_exp_types()]), - len(self.varargs)) + result = ('%s in call to %s with format string "%s"\n' + ' expected %i extra arguments:\n' + % (self._get_desc_prefix(), + self.funcname, + self.fmt.fmt_string, + self.fmt.num_expected())) + for (arg, exp_type) in self.fmt.iter_exp_types(): + result += ' %s\n' % describe_type(exp_type) + if len(self.varargs) == 0: + result += ' but got none\n' + else: + result += ' but got %i:\n' % len(self.varargs) + for arg in self.varargs: + result += ' %s\n' % describe_type(arg.type) + return result def _get_desc_prefix(self): raise NotImplementedError @@ -450,8 +458,11 @@ class MismatchingType(ParsedFormatStringError): result += describe_precision(va.operand.type) return result - return (' argument %i ("%s") had type %s\n' - ' but was expecting %s for format code "%s"\n' + return (' argument %i ("%s") had type\n' + ' %s\n' + ' but was expecting\n' + ' %s\n' + ' for format code "%s"\n' % (self.arg_num, self.vararg, describe_type(self.vararg.type), describe_type(self.exp_type), self.arg_fmt_string)) diff --git a/testcpychecker.py b/testcpychecker.py index a7cb255..3a00576 100644 --- a/testcpychecker.py +++ b/testcpychecker.py @@ -126,8 +126,11 @@ socket_htons(PyObject *self, PyObject *args) self.assertFindsError(src, '$(SRCFILE): In function ‘socket_htons’:\n' '$(SRCFILE):17:26: error: Mismatching type in call to PyArg_ParseTuple with format code "i:htons" [-fpermissive]\n' - ' argument 3 ("&x1") had type "long unsigned int *" (pointing to 64 bits)\n' - ' but was expecting "int *" (pointing to 32 bits) for format code "i"\n') + ' argument 3 ("&x1") had type\n' + ' "long unsigned int *" (pointing to 64 bits)\n' + ' but was expecting\n' + ' "int *" (pointing to 32 bits)\n' + ' for format code "i"\n') def test_not_enough_varargs(self): src = """ @@ -142,7 +145,11 @@ not_enough_varargs(PyObject *self, PyObject *args) """ self.assertFindsError(src, '$(SRCFILE): In function ‘not_enough_varargs’:\n' - '$(SRCFILE):13:25: error: Not enough arguments in call to PyArg_ParseTuple with format string "i" : expected 1 extra arguments ("int *" (pointing to 32 bits)), but got 0 [-fpermissive]\n') + '$(SRCFILE):13:25: error: Not enough arguments in call to PyArg_ParseTuple with format string "i"\n' + ' expected 1 extra arguments:\n' + ' "int *" (pointing to 32 bits)\n' + ' but got none\n' + ' [-fpermissive]\n') def test_too_many_varargs(self): src = """ @@ -158,7 +165,13 @@ too_many_varargs(PyObject *self, PyObject *args) """ self.assertFindsError(src, '$(SRCFILE): In function ‘too_many_varargs’:\n' - '$(SRCFILE):14:26: error: Too many arguments in call to PyArg_ParseTuple with format string "i" : expected 1 extra arguments ("int *" (pointing to 32 bits)), but got 2 [-fpermissive]\n') + '$(SRCFILE):14:26: error: Too many arguments in call to PyArg_ParseTuple with format string "i"\n' + ' expected 1 extra arguments:\n' + ' "int *" (pointing to 32 bits)\n' + ' but got 2:\n' + ' "int *" (pointing to 32 bits)\n' + ' "int *" (pointing to 32 bits)\n' + ' [-fpermissive]\n') def test_correct_usage(self): src = """ @@ -229,8 +242,10 @@ correct_usage(PyObject *self, PyObject *args) def get_expected_error(self): return ('$(SRCFILE): In function ‘%(function_name)s’:\n' '$(SRCFILE):%(linenum)i:%(colnum)i: error: Mismatching type in call to %(funcname)s with format code "%(code)s" [-fpermissive]\n' - ' argument %(argindex)i ("&val") had type "void * *"\n' - ' but was expecting "%(exptypename)s *"') + ' argument %(argindex)i ("&val") had type\n' + ' "void * *"\n' + ' but was expecting\n' + ' "%(exptypename)s *"') # we stop there, to avoid spelling out the various possible # (pointing to N bits) # variants of the message diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/stderr.txt b/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/stderr.txt index 278daf8..88340a2 100644 --- a/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/stderr.txt +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/stderr.txt @@ -1,4 +1,7 @@ tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/input.c: In function ‘incorrect_code_z_hash’: tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/input.c:34:26: error: Mismatching type in call to PyArg_ParseTuple with format code "z#" [-fpermissive] - argument 4 ("&len") had type "float *" (pointing to 32 bits) - but was expecting "Py_ssize_t *" for format code "z#" + argument 4 ("&len") had type + "float *" (pointing to 32 bits) + but was expecting + "Py_ssize_t *" + for format code "z#" diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/stderr.txt b/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/stderr.txt index aa46e20..9558f79 100644 --- a/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/stderr.txt +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/stderr.txt @@ -1,7 +1,13 @@ tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/input.c: In function ‘incorrect_usage_of_S_and_U’: tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/input.c:29:26: error: Mismatching type in call to PyArg_ParseTuple with format code "SU" [-fpermissive] - argument 3 ("&val1") had type "int *" (pointing to 32 bits) - but was expecting one of "PyStringObject * *" or "PyObject * *" for format code "S" + argument 3 ("&val1") had type + "int *" (pointing to 32 bits) + but was expecting + one of "PyStringObject * *" or "PyObject * *" + for format code "S" tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/input.c:29:26: error: Mismatching type in call to PyArg_ParseTuple with format code "SU" [-fpermissive] - argument 4 ("&val2") had type "int *" (pointing to 32 bits) - but was expecting one of "PyUnicodeObject * *" or "PyObject * *" for format code "U" + argument 4 ("&val2") had type + "int *" (pointing to 32 bits) + but was expecting + one of "PyUnicodeObject * *" or "PyObject * *" + for format code "U" diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/stderr.txt b/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/stderr.txt index 454911b..f668a2b 100644 --- a/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/stderr.txt +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/stderr.txt @@ -1,27 +1,62 @@ tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c: In function ‘incorrect_usages_of_converter’: -tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:36:26: error: Not enough arguments in call to PyArg_ParseTuple with format string "O&" : expected 2 extra arguments ("int (converter)(PyObject *, T*)" for some type T, "T*" for some type T), but got 0 [-fpermissive] -tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:39:26: error: Not enough arguments in call to PyArg_ParseTuple with format string "O&" : expected 2 extra arguments ("int (converter)(PyObject *, T*)" for some type T, "T*" for some type T), but got 1 [-fpermissive] +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:36:26: error: Not enough arguments in call to PyArg_ParseTuple with format string "O&" + expected 2 extra arguments: + "int (converter)(PyObject *, T*)" for some type T + "T*" for some type T + but got none + [-fpermissive] +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:39:26: error: Not enough arguments in call to PyArg_ParseTuple with format string "O&" + expected 2 extra arguments: + "int (converter)(PyObject *, T*)" for some type T + "T*" for some type T + but got 1: + "int" + [-fpermissive] tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:44:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] - argument 3 ("42") had type "int" - but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" + argument 3 ("42") had type + "int" + but was expecting + "int (converter)(PyObject *, T*)" for some type T + for format code "O&" tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:49:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] - argument 3 ("&i0") had type "int *" (pointing to 32 bits) - but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" + argument 3 ("&i0") had type + "int *" (pointing to 32 bits) + but was expecting + "int (converter)(PyObject *, T*)" for some type T + for format code "O&" tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:54:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] - argument 3 ("not_returning_int") had type "void (*fn) ()" - but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" + argument 3 ("not_returning_int") had type + "void (*fn) ()" + but was expecting + "int (converter)(PyObject *, T*)" for some type T + for format code "O&" tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:57:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] - argument 3 ("not_enough_args") had type "int (*fn) (struct PyObject *)" - but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" + argument 3 ("not_enough_args") had type + "int (*fn) (struct PyObject *)" + but was expecting + "int (converter)(PyObject *, T*)" for some type T + for format code "O&" tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:60:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] - argument 3 ("too_many_args") had type "int (*fn) (struct PyObject *, int *, int)" - but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" + argument 3 ("too_many_args") had type + "int (*fn) (struct PyObject *, int *, int)" + but was expecting + "int (converter)(PyObject *, T*)" for some type T + for format code "O&" tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:63:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] - argument 3 ("not_taking_PyObjectPtr") had type "int (*fn) (int, int)" - but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" + argument 3 ("not_taking_PyObjectPtr") had type + "int (*fn) (int, int)" + but was expecting + "int (converter)(PyObject *, T*)" for some type T + for format code "O&" tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:68:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] - argument 4 ("42") had type "int" - but was expecting "Py_ssize_t *" (pointing to 64 bits) (from second argument of "int (*fn) (struct PyObject *, Py_ssize_t *)") for format code "O&" + argument 4 ("42") had type + "int" + but was expecting + "Py_ssize_t *" (pointing to 64 bits) (from second argument of "int (*fn) (struct PyObject *, Py_ssize_t *)") + for format code "O&" tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:73:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] - argument 4 ("&i0") had type "int *" (pointing to 32 bits) - but was expecting "Py_ssize_t *" (pointing to 64 bits) (from second argument of "int (*fn) (struct PyObject *, Py_ssize_t *)") for format code "O&" + argument 4 ("&i0") had type + "int *" (pointing to 32 bits) + but was expecting + "Py_ssize_t *" (pointing to 64 bits) (from second argument of "int (*fn) (struct PyObject *, Py_ssize_t *)") + for format code "O&"

1 0

[gcc-python-plugin] Implement verification of the "O&" format code (converter callback, followed by appropriate arg)
by David Hugh Malcolm 24 Jun '11

24 Jun '11

commit c00b06553d71d2d52c128b3d63f46308dfb87970 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Fri Jun 24 19:26:59 2011 -0400 Implement verification of the "O&" format code (converter callback, followed by appropriate arg) libcpychecker/PyArg_ParseTuple.py | 156 +++++++++++++++---- testcpychecker.py | 4 +- .../PyArg_ParseTuple/correct_converter/input.c | 42 ++++++ .../PyArg_ParseTuple/correct_converter/script.py | 19 +++ .../PyArg_ParseTuple/incorrect_converters/input.c | 91 ++++++++++++ .../incorrect_converters/script.py | 19 +++ .../incorrect_converters/stderr.txt | 27 ++++ 7 files changed, 323 insertions(+), 35 deletions(-) --- diff --git a/libcpychecker/PyArg_ParseTuple.py b/libcpychecker/PyArg_ParseTuple.py index e889595..f0b0687 100644 --- a/libcpychecker/PyArg_ParseTuple.py +++ b/libcpychecker/PyArg_ParseTuple.py @@ -153,9 +153,89 @@ class ConcreteUnit(FormatUnit): FormatUnit.__init__(self, code) self.expected_types = expected_types -class Converter(FormatUnit): + def get_expected_types(self): + return self.expected_types + + +# Handle the "O&" format code +class Conversion(FormatUnit): def __init__(self, code): - FormatUnit.__init__(self, code) # FIXME: how to handle this? + FormatUnit.__init__(self, code) + self.callback = ConverterCallbackType(self) + self.result = ConverterResultType(self) + + def get_expected_types(self): + # We will discover the actual types as we go, using "self" to bind + # together the two arguments + return [self.callback, self.result] + +class AwkwardType: + pass + +class ConverterCallbackType(AwkwardType): + def __init__(self, conv): + self.conv = conv + self.actual_type = None + + def is_compatible(self, actual_type): + # We should be encountering a function pointer of type: + # int (fn)(PyObject *, T*) + # The result type (next argument) should be a T* + if not isinstance(actual_type, gcc.PointerType): + return False + + signature = actual_type.dereference + if not isinstance(signature, gcc.FunctionType): + return False + + # Check return type: + if signature.type != gcc.Type.int(): + return False + + # Check argument types: + if len(signature.argument_types) != 2: + return False + + if not compatible_type(signature.argument_types[0], + get_PyObject().pointer): + return False + + if not isinstance(signature.argument_types[1], gcc.PointerType): + return False + + # Write back to the ConverterResultType with the second arg: + log('2nd argument of converter should be of type %s' % signature.argument_types[1]) + self.conv.result.type = signature.argument_types[1] + self.actual_type = actual_type + + return True + + def describe(self): + return '"int (converter)(PyObject *, T*)" for some type T' + +class ConverterResultType(AwkwardType): + def __init__(self, conv): + self.conv = conv + self.type = None + + def is_compatible(self, actual_type): + if not isinstance(actual_type, gcc.PointerType): + return False + + # If something went wrong with figuring out the type, we can't check + # it: + if self.type is None: + return True + + return compatible_type(self.type, actual_type) + + def describe(self): + if self.type: + return ('%s (from second argument of %s)' + % (describe_type(self.type), + describe_type(self.conv.callback.actual_type))) + else: + return '"T*" for some type T' class PyArgParseFmt: """ @@ -177,7 +257,7 @@ class PyArgParseFmt: the expected types of the varargs """ for arg in self.args: - for exp_type in arg.expected_types: + for exp_type in arg.get_expected_types(): yield (arg, exp_type) @classmethod @@ -266,17 +346,8 @@ class PyArgParseFmt: elif next == '?': raise UnhandledCode(richloc, fmt_string, c + next) # FIXME elif next == '&': - # FIXME: can't really handle this case as is, fixing for fcntmodule.c - result.args.append(Converter('O&')) + result.args.append(Conversion('O&')) i += 1 - #'O&', - #[gcc.Type.int().pointer, # FIXME: this is a converter - # - # # FIXME: this should be obtained from the - # # converter's type: - # gcc.Type.int().pointer]) - #result += ['int ( PyObject * object , int * target )', # converter - # 'int *'] # FIXME, anything else: result.add_argument('O', [get_PyObject().pointer.pointer]) @@ -313,6 +384,32 @@ class ParsedFormatStringError(FormatStringError): self.funcname = funcname self.fmt = fmt +def describe_precision(t): + if hasattr(t, 'precision'): + return ' (pointing to %i bits)' % t.precision + else: + return '' + +def describe_type(t): + if isinstance(t, AwkwardType): + return t.describe() + if isinstance(t, tuple): + result = 'one of ' + ' or '.join(['"%s"' % tp for tp in t]) + else: + # Special-case handling of function types, to avoid embedding the ID: + # c.f. void (*<T792>) (void) + if isinstance(t, gcc.PointerType): + if isinstance(t.dereference, gcc.FunctionType): + signature = t.dereference + return ('"%s (*fn) (%s)"' % + (signature.type, + ', '.join([str(argtype) + for argtype in signature.argument_types]))) + result = '"%s"' % t + if hasattr(t, 'dereference'): + result += describe_precision(t.dereference) + return result + class WrongNumberOfVars(ParsedFormatStringError): def __init__(self, funcname, fmt, varargs): ParsedFormatStringError.__init__(self, funcname, fmt) @@ -324,7 +421,7 @@ class WrongNumberOfVars(ParsedFormatStringError): self.funcname, self.fmt.fmt_string, self.fmt.num_expected(), - ','.join([str(exp_type) for (arg, exp_type) in self.fmt.iter_exp_types()]), + ', '.join([describe_type(exp_type) for (arg, exp_type) in self.fmt.iter_exp_types()]), len(self.varargs)) def _get_desc_prefix(self): @@ -347,31 +444,16 @@ class MismatchingType(ParsedFormatStringError): self.vararg = vararg def extra_info(self): - def _describe_precision(t): - if hasattr(t, 'precision'): - return ' (pointing to %i bits)' % t.precision - else: - return '' - def _describe_vararg(va): result = '"%s"' % va.type if hasattr(va, 'operand'): - result += _describe_precision(va.operand.type) + result += describe_precision(va.operand.type) return result - def _describe_exp_type(t): - if isinstance(t, tuple): - result = 'one of ' + ' or '.join(['"%s"' % tp for tp in t]) - else: - result = '"%s"' % t - if hasattr(t, 'dereference'): - result += _describe_precision(t.dereference) - return result - return (' argument %i ("%s") had type %s\n' ' but was expecting %s for format code "%s"\n' - % (self.arg_num, self.vararg, _describe_vararg(self.vararg), - _describe_exp_type(self.exp_type), self.arg_fmt_string)) + % (self.arg_num, self.vararg, describe_type(self.vararg.type), + describe_type(self.exp_type), self.arg_fmt_string)) def __str__(self): return ('Mismatching type in call to %s with format code "%s"' @@ -390,6 +472,10 @@ def compatible_type(exp_type, actual_type): # Didn't match any of them: return False + # Support the "O&" converter code: + if isinstance(exp_type, AwkwardType): + return exp_type.is_compatible(actual_type) + assert isinstance(exp_type, gcc.Type) or isinstance(exp_type, gcc.TypeDecl) assert isinstance(actual_type, gcc.Type) or isinstance(actual_type, gcc.TypeDecl) @@ -493,7 +579,11 @@ def check_pyargs(fun): err = MismatchingType(funcname, fmt, index + varargs_idx + 1, exp_arg.code, exp_type, vararg) - gcc.permerror(vararg.location, + if hasattr(vararg, 'location'): + loc = vararg.location + else: + loc = stmt.loc + gcc.permerror(loc, str(err)) sys.stderr.write(err.extra_info()) diff --git a/testcpychecker.py b/testcpychecker.py index 33f78e4..a7cb255 100644 --- a/testcpychecker.py +++ b/testcpychecker.py @@ -142,7 +142,7 @@ not_enough_varargs(PyObject *self, PyObject *args) """ self.assertFindsError(src, '$(SRCFILE): In function ‘not_enough_varargs’:\n' - '$(SRCFILE):13:25: error: Not enough arguments in call to PyArg_ParseTuple with format string "i" : expected 1 extra arguments (int *), but got 0 [-fpermissive]\n') + '$(SRCFILE):13:25: error: Not enough arguments in call to PyArg_ParseTuple with format string "i" : expected 1 extra arguments ("int *" (pointing to 32 bits)), but got 0 [-fpermissive]\n') def test_too_many_varargs(self): src = """ @@ -158,7 +158,7 @@ too_many_varargs(PyObject *self, PyObject *args) """ self.assertFindsError(src, '$(SRCFILE): In function ‘too_many_varargs’:\n' - '$(SRCFILE):14:26: error: Too many arguments in call to PyArg_ParseTuple with format string "i" : expected 1 extra arguments (int *), but got 2 [-fpermissive]\n') + '$(SRCFILE):14:26: error: Too many arguments in call to PyArg_ParseTuple with format string "i" : expected 1 extra arguments ("int *" (pointing to 32 bits)), but got 2 [-fpermissive]\n') def test_correct_usage(self): src = """ diff --git a/tests/cpychecker/PyArg_ParseTuple/correct_converter/input.c b/tests/cpychecker/PyArg_ParseTuple/correct_converter/input.c new file mode 100644 index 0000000..5cbdd4b --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/correct_converter/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> + +/* Adapted from Python's Objects/listobject.c:listindex */ +PyObject * +correct_usage_of_converter(PyObject *self, PyObject *args) +{ + Py_ssize_t start, stop; + if (!PyArg_ParseTuple(args, "O&O&", + _PyEval_SliceIndex, &start, + _PyEval_SliceIndex, &stop)) { + return NULL; + } + + Py_RETURN_NONE; +} + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/PyArg_ParseTuple/correct_converter/script.py b/tests/cpychecker/PyArg_ParseTuple/correct_converter/script.py new file mode 100644 index 0000000..e120c53 --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/correct_converter/script.py @@ -0,0 +1,19 @@ +# 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() diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c b/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c new file mode 100644 index 0000000..fc6de01 --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c @@ -0,0 +1,91 @@ +/* + 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> + +extern void not_returning_int(void); +extern int not_enough_args(PyObject *); +extern int too_many_args(PyObject *, int *, int); +extern int not_taking_PyObjectPtr(int, int); +extern int convert_to_ssize(PyObject *, Py_ssize_t *); + +PyObject * +incorrect_usages_of_converter(PyObject *self, PyObject *args) +{ + int i0; + int i1; + Py_ssize_t ssize0; + + /* Not enough args: */ + if (!PyArg_ParseTuple(args, "O&")) { + return NULL; + } + if (!PyArg_ParseTuple(args, "O&", 42)) { + return NULL; + } + + /* First arg not even a pointer: */ + if (!PyArg_ParseTuple(args, "O&", 42, &i1)) { + return NULL; + } + + /* First arg not a function: */ + if (!PyArg_ParseTuple(args, "O&", &i0, &i1)) { + return NULL; + } + + /* Signature of callback is wrong: */ + if (!PyArg_ParseTuple(args, "O&", not_returning_int, &i1)) { + return NULL; + } + if (!PyArg_ParseTuple(args, "O&", not_enough_args, &i1)) { + return NULL; + } + if (!PyArg_ParseTuple(args, "O&", too_many_args, &i1)) { + return NULL; + } + if (!PyArg_ParseTuple(args, "O&", not_taking_PyObjectPtr, &i1)) { + return NULL; + } + + /* Second arg is not a pointer */ + if (!PyArg_ParseTuple(args, "O&", convert_to_ssize, 42)) { + return NULL; + } + + /* Mismatching second arg: */ + if (!PyArg_ParseTuple(args, "O&", convert_to_ssize, &i0)) { + return NULL; + } + + /* Correct usage: */ + if (!PyArg_ParseTuple(args, "O&", convert_to_ssize, &ssize0)) { + return NULL; + } + + Py_RETURN_NONE; +} + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/script.py b/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/script.py new file mode 100644 index 0000000..e120c53 --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/script.py @@ -0,0 +1,19 @@ +# 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() diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/stderr.txt b/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/stderr.txt new file mode 100644 index 0000000..454911b --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_converters/stderr.txt @@ -0,0 +1,27 @@ +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c: In function ‘incorrect_usages_of_converter’: +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:36:26: error: Not enough arguments in call to PyArg_ParseTuple with format string "O&" : expected 2 extra arguments ("int (converter)(PyObject *, T*)" for some type T, "T*" for some type T), but got 0 [-fpermissive] +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:39:26: error: Not enough arguments in call to PyArg_ParseTuple with format string "O&" : expected 2 extra arguments ("int (converter)(PyObject *, T*)" for some type T, "T*" for some type T), but got 1 [-fpermissive] +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:44:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] + argument 3 ("42") had type "int" + but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:49:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] + argument 3 ("&i0") had type "int *" (pointing to 32 bits) + but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:54:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] + argument 3 ("not_returning_int") had type "void (*fn) ()" + but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:57:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] + argument 3 ("not_enough_args") had type "int (*fn) (struct PyObject *)" + but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:60:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] + argument 3 ("too_many_args") had type "int (*fn) (struct PyObject *, int *, int)" + but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:63:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] + argument 3 ("not_taking_PyObjectPtr") had type "int (*fn) (int, int)" + but was expecting "int (converter)(PyObject *, T*)" for some type T for format code "O&" +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:68:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] + argument 4 ("42") had type "int" + but was expecting "Py_ssize_t *" (pointing to 64 bits) (from second argument of "int (*fn) (struct PyObject *, Py_ssize_t *)") for format code "O&" +tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:73:26: error: Mismatching type in call to PyArg_ParseTuple with format code "O&" [-fpermissive] + argument 4 ("&i0") had type "int *" (pointing to 32 bits) + but was expecting "Py_ssize_t *" (pointing to 64 bits) (from second argument of "int (*fn) (struct PyObject *, Py_ssize_t *)") for format code "O&"

1 0

[gcc-python-plugin] Fix breakage of the various "es" and "et" format codes introduced in last commit
by David Hugh Malcolm 24 Jun '11

24 Jun '11

commit 2b1b162224a41d8df9823d5c009ba2d0438e5883 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Fri Jun 24 17:59:53 2011 -0400 Fix breakage of the various "es" and "et" format codes introduced in last commit libcpychecker/PyArg_ParseTuple.py | 5 ++++- 1 files changed, 4 insertions(+), 1 deletions(-) --- diff --git a/libcpychecker/PyArg_ParseTuple.py b/libcpychecker/PyArg_ParseTuple.py index 5452436..e889595 100644 --- a/libcpychecker/PyArg_ParseTuple.py +++ b/libcpychecker/PyArg_ParseTuple.py @@ -32,6 +32,9 @@ def log(msg, indent=0): from gccutils import get_src_for_loc, get_global_typedef +def get_const_char_ptr(): + return gcc.Type.char().const_equivalent.pointer + def get_const_char_ptr_ptr(): if const_correctness: return gcc.Type.char().const_equivalent.pointer.pointer @@ -231,7 +234,7 @@ class PyArgParseFmt: elif c == 'e': if next in ['s', 't']: arg = ConcreteUnit('e' + next, - [get_const_char_ptr_ptr(), + [get_const_char_ptr(), gcc.Type.char().pointer.pointer]) i += 1 if i < len(fmt_string):

1 0

[gcc-python-plugin] Add a way of turning of const-correctness for "const char*" checking
by David Hugh Malcolm 24 Jun '11

24 Jun '11

commit 737eb35e6842e477cb139ec09826a0f2c777f00f Author: David Malcolm <dmalcolm(a)redhat.com> Date: Fri Jun 24 17:54:37 2011 -0400 Add a way of turning of const-correctness for "const char*" checking This test was showing lots of (apparently) false positives when running the checker against CPython 2.7 libcpychecker/PyArg_ParseTuple.py | 19 ++++++++++++------- 1 files changed, 12 insertions(+), 7 deletions(-) --- diff --git a/libcpychecker/PyArg_ParseTuple.py b/libcpychecker/PyArg_ParseTuple.py index 526403f..5452436 100644 --- a/libcpychecker/PyArg_ParseTuple.py +++ b/libcpychecker/PyArg_ParseTuple.py @@ -24,14 +24,21 @@ import gcc import sys +const_correctness = True + def log(msg, indent=0): if 0: sys.stderr.write('%s%s\n' % (' ' * indent, msg)) from gccutils import get_src_for_loc, get_global_typedef -def get_const_char_ptr(): - return gcc.Type.char().const_equivalent.pointer +def get_const_char_ptr_ptr(): + if const_correctness: + return gcc.Type.char().const_equivalent.pointer.pointer + else: + # Allow people to be sloppy about const-correctness here: + return (gcc.Type.char().const_equivalent.pointer.pointer, + gcc.Type.char().pointer.pointer) def get_Py_ssize_t(): return get_global_typedef('Py_ssize_t') @@ -212,21 +219,19 @@ class PyArgParseFmt: elif c in ['s', 'z']: # string, possibly NULL/None if next == '#': result.add_argument(c + '#', - [get_const_char_ptr().pointer, + [get_const_char_ptr_ptr(), get_hash_size_type().pointer]) i += 1 elif next == '*': result.add_argument(c + '*', [get_Py_buffer().pointer]) i += 1 else: - result.add_argument(c, [get_const_char_ptr().pointer]) - # FIXME: seeing lots of (const char**) versus (char**) mismatches here - # do we care? + result.add_argument(c, [get_const_char_ptr_ptr()]) elif c == 'e': if next in ['s', 't']: arg = ConcreteUnit('e' + next, - [get_const_char_ptr(), + [get_const_char_ptr_ptr(), gcc.Type.char().pointer.pointer]) i += 1 if i < len(fmt_string):

1 0

[gcc-python-plugin] Format codes "U" and "S" can support several different argument types
by David Hugh Malcolm 24 Jun '11

24 Jun '11

commit 90532beb8e51a776f0e235b8edd818cca790097b Author: David Malcolm <dmalcolm(a)redhat.com> Date: Fri Jun 24 17:31:55 2011 -0400 Format codes "U" and "S" can support several different argument types libcpychecker/PyArg_ParseTuple.py | 20 +++++- testcpychecker.py | 9 +-- .../PyArg_ParseTuple/correct_codes_S_and_U/input.c | 68 ++++++++++++++++++++ .../correct_codes_S_and_U/script.py | 19 ++++++ .../incorrect_codes_S_and_U/input.c | 41 ++++++++++++ .../incorrect_codes_S_and_U/script.py | 19 ++++++ .../incorrect_codes_S_and_U/stderr.txt | 7 ++ 7 files changed, 175 insertions(+), 8 deletions(-) --- diff --git a/libcpychecker/PyArg_ParseTuple.py b/libcpychecker/PyArg_ParseTuple.py index c1b8607..526403f 100644 --- a/libcpychecker/PyArg_ParseTuple.py +++ b/libcpychecker/PyArg_ParseTuple.py @@ -244,9 +244,11 @@ class PyArgParseFmt: else: result.add_argument('u', [Py_UNICODE().pointer.pointer]) elif c == 'S': - result.add_argument('S', [get_PyStringObject().pointer.pointer]) + result.add_argument('S', [(get_PyStringObject().pointer.pointer, + get_PyObject().pointer.pointer)]) elif c == 'U': - result.add_argument('U', [get_PyUnicodeObject().pointer.pointer]) + result.add_argument('U', [(get_PyUnicodeObject().pointer.pointer, + get_PyObject().pointer.pointer)]) elif c == 'O': # object if next == '!': result.add_argument('O!', @@ -350,7 +352,10 @@ class MismatchingType(ParsedFormatStringError): return result def _describe_exp_type(t): - result = '"%s"' % t + if isinstance(t, tuple): + result = 'one of ' + ' or '.join(['"%s"' % tp for tp in t]) + else: + result = '"%s"' % t if hasattr(t, 'dereference'): result += _describe_precision(t.dereference) return result @@ -368,6 +373,15 @@ def compatible_type(exp_type, actual_type): log('comparing exp_type: %s (%r) with actual_type: %s (%r)' % (exp_type, exp_type, actual_type, actual_type)) log('type(exp_type): %r %s' % (type(exp_type), type(exp_type))) + # Support exp_type being actually a tuple of expected types (we need this + # for "S" and "U"): + if isinstance(exp_type, tuple): + for exp in exp_type: + if compatible_type(exp, actual_type): + return True + # Didn't match any of them: + return False + assert isinstance(exp_type, gcc.Type) or isinstance(exp_type, gcc.TypeDecl) assert isinstance(actual_type, gcc.Type) or isinstance(actual_type, gcc.TypeDecl) diff --git a/testcpychecker.py b/testcpychecker.py index a1a76f7..33f78e4 100644 --- a/testcpychecker.py +++ b/testcpychecker.py @@ -371,11 +371,10 @@ correct_usage(PyObject *self, PyObject *args) # 'int *', # 'int *']) - def test_format_code_S(self): - self._test_format_code('S', ['PyStringObject *']) - - def test_format_code_U(self): - self._test_format_code('U', ['PyUnicodeObject *']) + # Codes "S" and "U" require some special treatment, as they can support + # multiple types. We tests them via these selftests: + # tests/cpychecker/PyArg_ParseTuple/correct_codes_S_and_U/ + # tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/ def test_format_code_t_hash(self): self._test_format_code('t#', ['char *', 'Py_ssize_t']) diff --git a/tests/cpychecker/PyArg_ParseTuple/correct_codes_S_and_U/input.c b/tests/cpychecker/PyArg_ParseTuple/correct_codes_S_and_U/input.c new file mode 100644 index 0000000..c7e8fde --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/correct_codes_S_and_U/input.c @@ -0,0 +1,68 @@ +/* + 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/>. +*/ + +/* + Verify that the checker can cope with format codes that reference + specific object subtypes (e.g. PyStringObject) but are supplied + a PyObject ** instead. + + This was erroneously giving errors like this: + error: Mismatching type in call to PyArg_ParseTuple with format code "S" [-fpermissive] + argument 3 ("&stringobj") had type "struct PyObject * *" + but was expecting "PyStringObject * *" for format code "S" + which is overconstraining things: a (PyObject**) is fine there. +*/ + +#include <Python.h> + +static PyObject * +less_rigid_code_S(PyObject *self, PyObject *args) +{ + /* + Both of these ought to be acceptable for code "S": + */ + PyObject *S_baseobj; + PyStringObject *S_stringobj; + + if (!PyArg_ParseTuple(args, "SS", + &S_baseobj, + &S_stringobj)) { + return NULL; + } + + Py_RETURN_NONE; +} + +static PyObject * +less_rigid_code_U(PyObject *self, PyObject *args) +{ + /* + Both of these ought to be acceptable for code "U": + */ + PyObject *U_baseobj; + PyUnicodeObject *U_uniobj; + + if (!PyArg_ParseTuple(args, "UU", + &U_baseobj, + &U_uniobj)) { + return NULL; + } + + Py_RETURN_NONE; +} diff --git a/tests/cpychecker/PyArg_ParseTuple/correct_codes_S_and_U/script.py b/tests/cpychecker/PyArg_ParseTuple/correct_codes_S_and_U/script.py new file mode 100644 index 0000000..e120c53 --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/correct_codes_S_and_U/script.py @@ -0,0 +1,19 @@ +# 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() diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/input.c b/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/input.c new file mode 100644 index 0000000..85c9508 --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/input.c @@ -0,0 +1,41 @@ +/* + 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> + +PyObject * +incorrect_usage_of_S_and_U(PyObject *self, PyObject *args) +{ + int val1; + int val2; + + /* Incorrect: mismatching types: */ + if (!PyArg_ParseTuple(args, "SU", &val1, &val2)) { + return NULL; + } + Py_RETURN_NONE; +} + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/script.py b/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/script.py new file mode 100644 index 0000000..e120c53 --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/script.py @@ -0,0 +1,19 @@ +# 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() diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/stderr.txt b/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/stderr.txt new file mode 100644 index 0000000..aa46e20 --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/stderr.txt @@ -0,0 +1,7 @@ +tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/input.c: In function ‘incorrect_usage_of_S_and_U’: +tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/input.c:29:26: error: Mismatching type in call to PyArg_ParseTuple with format code "SU" [-fpermissive] + argument 3 ("&val1") had type "int *" (pointing to 32 bits) + but was expecting one of "PyStringObject * *" or "PyObject * *" for format code "S" +tests/cpychecker/PyArg_ParseTuple/incorrect_codes_S_and_U/input.c:29:26: error: Mismatching type in call to PyArg_ParseTuple with format code "SU" [-fpermissive] + argument 4 ("&val2") had type "int *" (pointing to 32 bits) + but was expecting one of "PyUnicodeObject * *" or "PyObject * *" for format code "U"

1 0

[gcc-python-plugin] Fix erroneous error messages for the various "s" and "z" format codes
by David Hugh Malcolm 24 Jun '11

24 Jun '11

commit 38f1ac50b297c63ffea6c4d7f748d5030d19bbc4 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Fri Jun 24 16:24:46 2011 -0400 Fix erroneous error messages for the various "s" and "z" format codes Reported and fixed by Tom Tromey: https://fedorahosted.org/pipermail/gcc-python-plugin/2011-June/000009.html libcpychecker/PyArg_ParseTuple.py | 6 +- .../PyArg_ParseTuple/incorrect_code_z_hash/input.c | 47 ++++++++++++++++++++ .../incorrect_code_z_hash/script.py | 19 ++++++++ .../incorrect_code_z_hash/stderr.txt | 4 ++ 4 files changed, 73 insertions(+), 3 deletions(-) --- diff --git a/libcpychecker/PyArg_ParseTuple.py b/libcpychecker/PyArg_ParseTuple.py index 7ccf30e..c1b8607 100644 --- a/libcpychecker/PyArg_ParseTuple.py +++ b/libcpychecker/PyArg_ParseTuple.py @@ -211,15 +211,15 @@ class PyArgParseFmt: elif c in ['s', 'z']: # string, possibly NULL/None if next == '#': - result.add_argument('c#', + result.add_argument(c + '#', [get_const_char_ptr().pointer, get_hash_size_type().pointer]) i += 1 elif next == '*': - result.add_argument('c*', [get_Py_buffer().pointer]) + result.add_argument(c + '*', [get_Py_buffer().pointer]) i += 1 else: - result.add_argument('c', [get_const_char_ptr().pointer]) + result.add_argument(c, [get_const_char_ptr().pointer]) # FIXME: seeing lots of (const char**) versus (char**) mismatches here # do we care? diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/input.c b/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/input.c new file mode 100644 index 0000000..b68a95b --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/input.c @@ -0,0 +1,47 @@ +/* + 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/>. +*/ + +/* + Verify that the error message for bad types for code "z#" is correct + Bug reported in: + https://fedorahosted.org/pipermail/gcc-python-plugin/2011-June/000007.html +*/ + +#include <Python.h> + +static PyObject * +incorrect_code_z_hash(PyObject *self, PyObject *args) +{ + const char *str; + float len; /* This is incorrect; should be "int" */ + + if (!PyArg_ParseTuple(args, "z#", &str, &len)) { + return NULL; + } + + Py_RETURN_NONE; +} + +/* + PEP-7 +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/script.py b/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/script.py new file mode 100644 index 0000000..e120c53 --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/script.py @@ -0,0 +1,19 @@ +# 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() diff --git a/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/stderr.txt b/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/stderr.txt new file mode 100644 index 0000000..278daf8 --- /dev/null +++ b/tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/stderr.txt @@ -0,0 +1,4 @@ +tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/input.c: In function ‘incorrect_code_z_hash’: +tests/cpychecker/PyArg_ParseTuple/incorrect_code_z_hash/input.c:34:26: error: Mismatching type in call to PyArg_ParseTuple with format code "z#" [-fpermissive] + argument 4 ("&len") had type "float *" (pointing to 32 bits) + but was expecting "Py_ssize_t *" for format code "z#"

1 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

gcc-python-plugin-commits June 2011