gcc-python-plugin-commits September 2011

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

1 participants
71 discussions

[gcc-python-plugin] docs: add note about pygments dependency
by David Hugh Malcolm 07 Sep '11

07 Sep '11

commit ce341908079f1394843262ce4d3885107d000f40 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Wed Sep 7 15:13:21 2011 -0400 docs: add note about pygments dependency docs/basics.rst | 5 +++++ 1 files changed, 5 insertions(+), 0 deletions(-) --- diff --git a/docs/basics.rst b/docs/basics.rst index a549a3e..513cf6e 100644 --- a/docs/basics.rst +++ b/docs/basics.rst @@ -35,6 +35,11 @@ The plugin has the following requirements: http://pypi.python.org/pypi/six/ + * "pygments": The libcpychecker code uses the "pygments" Python + syntax-highlighting library when writing out error reports: + + http://pygments.org/ + Basic usage of the plugin =========================

1 0

[gcc-python-plugin] cpychecker: initial implementation of PyGILState_{Ensure|Release}
by David Hugh Malcolm 07 Sep '11

07 Sep '11

commit bead834f511edb25973813db20c8fdb1a6878e0d Author: David Malcolm <dmalcolm(a)redhat.com> Date: Wed Sep 7 05:31:54 2011 -0400 cpychecker: initial implementation of PyGILState_{Ensure|Release} libcpychecker/refcounts.py | 13 +++++++++++++ 1 files changed, 13 insertions(+), 0 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index 232b7d2..c8f7a11 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -949,6 +949,19 @@ class MyState(State): return [self.mktrans_nop(stmt, 'Py_Finalize')] ######################################################################## + # PyGILState_* + ######################################################################## + def impl_PyGILState_Ensure(self, stmt): + # http://docs.python.org/c-api/init.html#PyGILState_Ensure + # For now, treat it as a no-op: + return [self.mktrans_nop(stmt, 'PyGILState_Ensure')] + + def impl_PyGILState_Release(self, stmt): + # http://docs.python.org/c-api/init.html#PyGILState_Release + # For now, treat it as a no-op: + return [self.mktrans_nop(stmt, 'PyGILState_Release')] + + ######################################################################## # PyImport_* ######################################################################## def impl_PyImport_AppendInittab(self, stmt):

1 0

[gcc-python-plugin] cpychecker: remove stray line from previous commit
by David Hugh Malcolm 07 Sep '11

07 Sep '11

commit d8fcfc910d0252ea9d6b422042a966995e40d8d7 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Wed Sep 7 05:10:10 2011 -0400 cpychecker: remove stray line from previous commit libcpychecker/formatstrings.py | 1 - 1 files changed, 0 insertions(+), 1 deletions(-) --- diff --git a/libcpychecker/formatstrings.py b/libcpychecker/formatstrings.py index 4a048a5..696270f 100644 --- a/libcpychecker/formatstrings.py +++ b/libcpychecker/formatstrings.py @@ -292,7 +292,6 @@ def compatible_type(exp_type, actual_type, actualarg=None): def check_pyargs(fun): from libcpychecker.PyArg_ParseTuple import PyArgParseFmt - from libcpychecker.Py_BuildValue import PyBuildValueFmt def get_format_string(stmt, format_idx): fmt_code = stmt.args[format_idx]

1 0

[gcc-python-plugin] cpychecker: start generalizing PyArg_ParseTuple code to handle other format string APIs
by David Hugh Malcolm 07 Sep '11

07 Sep '11

commit 050963dd79f25e3995608cb163a6c48b1b66def8 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Wed Sep 7 05:06:57 2011 -0400 cpychecker: start generalizing PyArg_ParseTuple code to handle other format string APIs libcpychecker/PyArg_ParseTuple.py | 408 +---------------------------------- libcpychecker/__init__.py | 2 +- libcpychecker/diagnostics.py | 2 +- libcpychecker/formatstrings.py | 434 +++++++++++++++++++++++++++++++++++++ 4 files changed, 439 insertions(+), 407 deletions(-) --- diff --git a/libcpychecker/PyArg_ParseTuple.py b/libcpychecker/PyArg_ParseTuple.py index a99fd36..274f694 100644 --- a/libcpychecker/PyArg_ParseTuple.py +++ b/libcpychecker/PyArg_ParseTuple.py @@ -39,62 +39,9 @@ import gcc -import sys - -const_correctness = True - -from gccutils import get_src_for_loc, get_global_typedef - -from libcpychecker.utils import log +from libcpychecker.formatstrings import * from libcpychecker.types import * - -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_hash_size_type(with_size_t): - # Was PY_SSIZE_T_CLEAN defined? - if with_size_t: - return get_Py_ssize_t() - else: - return gcc.Type.int() - -class NullPointer: - # Dummy value, for pointer arguments that can legitimately be NULL - def describe(self): - return 'NULL' - -class CExtensionError(Exception): - # Base class for errors discovered by static analysis in C extension code - pass - -class FormatStringError(CExtensionError): - def __init__(self, fmt_string): - self.fmt_string = fmt_string - -class UnknownFormatChar(FormatStringError): - def __init__(self, fmt_string, ch): - FormatStringError.__init__(self, fmt_string) - self.ch = ch - - def __str__(self): - return "unknown format char in \"%s\": '%s'" % (self.fmt_string, self.ch) - -class UnhandledCode(UnknownFormatChar): - def __str__(self): - return "unhandled format code in \"%s\": '%s' (FIXME)" % (self.fmt_string, self.ch) - - -class MismatchedParentheses(FormatStringError): - def __str__(self): - return "mismatched parentheses in format string \"%s\"" % (self.fmt_string, ) +from libcpychecker.utils import log def _type_of_simple_arg(arg): # Convert 1-character argument code to a gcc.Type, covering the easy cases @@ -130,44 +77,6 @@ def _type_of_simple_arg(arg): if arg == 'D': return get_Py_complex() -class FormatUnit: - """ - One fragment of the string arg to PyArg_ParseTuple and friends - """ - def __init__(self, code): - self.code = code - - def get_expected_types(self): - # Return a list of the types expected for this format unit, - # either as gcc.Type instances, or as instances of AwkwardType - raise NotImplementedError - -class ConcreteUnit(FormatUnit): - """ - The common case: a fragment of a format string that corresponds to a - pre-determined list of types (often just a single element) - """ - def __init__(self, code, expected_types): - FormatUnit.__init__(self, code) - self.expected_types = expected_types - - def get_expected_types(self): - return self.expected_types - - def __repr__(self): - return 'ConcreteUnit(%r,%r)' % (self.code, self.expected_types) - -class AwkwardType: - """ - Base class for expected types within a format unit that need special - handling (e.g. for "O!" and "O&") - """ - def is_compatible(self, actual_type, actual_arg): - raise NotImplementedError - - def describe(self): - raise NotImplementedError - class TypeCheck(FormatUnit): """ Handler for the "O!" format code @@ -344,17 +253,10 @@ class ConverterResultType(AwkwardType): else: return '"T*" for some type T' -class PyArgParseFmt: +class PyArgParseFmt(ParsedFormatString): """ Python class representing the string arg to PyArg_ParseTuple and friends """ - def __init__(self, fmt_string): - self.fmt_string = fmt_string - self.args = [] - - def __repr__(self): - return ('PyArgParseFmt(fmt_string=%r, args=%r)' - % (self.fmt_string, self.args)) def add_argument(self, code, expected_types): self.args.append(ConcreteUnit(code, expected_types)) @@ -497,307 +399,3 @@ class PyArgParseFmt: raise MismatchedParentheses(fmt_string) return result - -class ParsedFormatStringError(FormatStringError): - def __init__(self, funcname, fmt): - FormatStringError.__init__(self, fmt.fmt_string) - 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, NullPointer): - return t.describe() - if isinstance(t, tuple): - result = 'one of ' + ' or '.join([describe_type(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) - self.varargs = varargs - - def __str__(self): - 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 - -class NotEnoughVars(WrongNumberOfVars): - def _get_desc_prefix(self): - return 'Not enough arguments' - -class TooManyVars(WrongNumberOfVars): - def _get_desc_prefix(self): - return 'Too many arguments' - -class MismatchingType(ParsedFormatStringError): - def __init__(self, funcname, fmt, arg_num, arg_fmt_string, exp_type, vararg): - super(self.__class__, self).__init__(funcname, fmt) - self.arg_num = arg_num - self.arg_fmt_string = arg_fmt_string - self.exp_type = exp_type - self.vararg = vararg - - def extra_info(self): - def _describe_vararg(va): - result = '"%s"' % va.type - if hasattr(va, 'operand'): - result += describe_precision(va.operand.type) - return result - - 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)) - - def __str__(self): - return ('Mismatching type in call to %s with format code "%s"' - % (self.funcname, self.fmt.fmt_string)) - -def compatible_type(exp_type, actual_type, actualarg=None): - 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)) - log('actualarg: %s (%r)', actualarg, actualarg) - - # 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, actualarg): - return True - # Didn't match any of them: - return False - - # Support the "O!" and "O&" converter codes: - if isinstance(exp_type, AwkwardType): - return exp_type.is_compatible(actual_type, actualarg) - - # Support the codes that can accept NULL: - if isinstance(exp_type, NullPointer): - if isinstance(actual_type, gcc.PointerType): - if isinstance(actual_type.dereference, gcc.VoidType): - # We have a (void*), double-check that it's actually NULL: - if actualarg: - if isinstance(actualarg, gcc.IntegerCst): - if actualarg.constant == 0: - # We have NULL: - return True - 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) - - # Try direct comparison: - if actual_type == exp_type: - return True - - # Sometimes we get the typedef rather than the type, for both exp and - # actual. Compare using the actual types, but report using the typedefs - # so that we can report that e.g. - # PyObject * * - # was expected, rather than: - # struct PyObject * * - if isinstance(exp_type, gcc.TypeDecl): - if compatible_type(exp_type.type, actual_type): - return True - - if isinstance(actual_type, gcc.TypeDecl): - if compatible_type(exp_type, actual_type.type): - return True - - # Dereference for pointers (and ptrs to ptrs etc): - if isinstance(actual_type, gcc.PointerType) and isinstance(exp_type, gcc.PointerType): - if compatible_type(actual_type.dereference, exp_type.dereference): - return True - - # Don't be too fussy about typedefs to integer types - # For instance: - # typedef unsigned PY_LONG_LONG gdb_py_ulongest; - # gives a different IntegerType instance to that of - # gcc.Type.long_long().unsigned_equivalent - # As long as the size, signedness etc are the same, let it go - if isinstance(actual_type, gcc.IntegerType) and isinstance(exp_type, gcc.IntegerType): - def compare_int_types(): - for attr in ('precision', 'unsigned', - 'const', 'volatile', 'restrict'): - if getattr(actual_type, attr) != getattr(exp_type, attr): - return False - return True - if compare_int_types(): - return True - - return False - -def check_pyargs(fun): - def get_format_string(stmt, format_idx): - fmt_code = stmt.args[format_idx] - # We can only cope with the easy case, when it's a AddrExpr(StringCst()) - # i.e. a reference to a string constant, i.e. a string literal in the C - # source: - if isinstance(fmt_code, gcc.AddrExpr): - operand = fmt_code.operand - if isinstance(operand, gcc.StringCst): - return operand.constant - - def check_keyword_array(stmt, idx): - keywords = stmt.args[idx] - if isinstance(keywords, gcc.AddrExpr): - operand = keywords.operand - if isinstance(operand, gcc.VarDecl): - # Caveat: "initial" will only be set up on the VarDecl of a - # global variable, or a "static" variable in function scope; - # for other local variables we appear to need to track the - # gimple statements to get the value at the callsite - initial = operand.initial - if isinstance(initial, gcc.Constructor): - elements = [None] * len(initial.elements) - for elt in initial.elements: - (num, contents) = elt - elt_idx = num.constant - if isinstance(contents, gcc.NopExpr): - contents = contents.operand - if isinstance(contents, gcc.AddrExpr): - contents = contents.operand - if isinstance(contents, gcc.StringCst): - elements[elt_idx] = contents.constant - elif isinstance(contents, gcc.IntegerCst): - elements[elt_idx] = contents.constant - if elements[-1] != 0: - gcc.permerror(stmt.loc, 'keywords to PyArg_ParseTupleAndKeywords are not NULL-terminated') - i = 0 - for elt in elements[0:-1]: - if not elt: - gcc.permerror(stmt.loc, 'keyword argument %d missing in PyArg_ParseTupleAndKeywords call' % i) - i = i + 1 - - def check_callsite(stmt, funcname, format_idx, varargs_idx, with_size_t): - log('got call at %s', stmt.loc) - log(get_src_for_loc(stmt.loc)) - # log('stmt: %r %s', (stmt, stmt)) - # log('args: %r', stmt.args) - # for arg in stmt.args: - # # log(' arg: %s %r', (arg, arg)) - - - # We expect the following args: - # args[0]: PyObject *input_tuple - # args[1]: char * format - # args[2...]: output pointers - - if len(stmt.args) > 1: - fmt_string = get_format_string(stmt, format_idx) - if fmt_string: - log('fmt_string: %r', fmt_string) - - loc = stmt.loc - - # Figure out expected types, based on the format string... - try: - fmt = PyArgParseFmt.from_string(fmt_string, with_size_t) - except FormatStringError: - exc = sys.exc_info()[1] - gcc.permerror(stmt.loc, str(exc)) - return - log('fmt: %r', fmt.args) - - exp_types = list(fmt.iter_exp_types()) - log('exp_types: %r', exp_types) - - # ...then compare them against the actual types: - varargs = stmt.args[varargs_idx:] - # log('varargs: %r', varargs) - if len(varargs) < len(exp_types): - gcc.permerror(loc, str(NotEnoughVars(funcname, fmt, varargs))) - return - - if len(varargs) > len(exp_types): - gcc.permerror(loc, str(TooManyVars(funcname, fmt, varargs))) - return - - for index, ((exp_arg, exp_type), vararg) in enumerate(zip(exp_types, varargs)): - if not compatible_type(exp_type, vararg.type, actualarg=vararg): - err = MismatchingType(funcname, fmt, - index + varargs_idx + 1, - exp_arg.code, exp_type, vararg) - if hasattr(vararg, 'location'): - loc = vararg.location - else: - loc = stmt.loc - gcc.permerror(loc, - str(err)) - sys.stderr.write(err.extra_info()) - - def maybe_check_callsite(stmt): - if stmt.fndecl: - # If "PY_SSIZE_T_CLEAN" is defined before #include <Python.h>, then - # the preprocessor is actually turning these into "_SizeT"-suffixed - # variants, which handle some format codes differently - - # FIXME: should we report the name as seen by the compiler? - # It doesn't appear in the CPython API docs - - if stmt.fndecl.name == 'PyArg_ParseTuple': - check_callsite(stmt, - 'PyArg_ParseTuple', - 1, 2, False) - elif stmt.fndecl.name == '_PyArg_ParseTuple_SizeT': - check_callsite(stmt, - 'PyArg_ParseTuple', - 1, 2, True) - elif stmt.fndecl.name == 'PyArg_ParseTupleAndKeywords': - check_keyword_array(stmt, 3) - check_callsite(stmt, - 'PyArg_ParseTupleAndKeywords', - 2, 4, False) - elif stmt.fndecl.name == '_PyArg_ParseTupleAndKeywords_SizeT': - check_keyword_array(stmt, 3) - check_callsite(stmt, - 'PyArg_ParseTupleAndKeywords', - 2, 4, True) - - if fun.cfg: - for bb in fun.cfg.basic_blocks: - if isinstance(bb.gimple, list): - for stmt in bb.gimple: - if stmt.loc: - gcc.set_location(stmt.loc) - if isinstance(stmt, gcc.GimpleCall): - maybe_check_callsite(stmt) diff --git a/libcpychecker/__init__.py b/libcpychecker/__init__.py index 47e5899..e54de04 100644 --- a/libcpychecker/__init__.py +++ b/libcpychecker/__init__.py @@ -16,7 +16,7 @@ # <http://www.gnu.org/licenses/>. import gcc -from libcpychecker.PyArg_ParseTuple import check_pyargs +from libcpychecker.formatstrings import check_pyargs from libcpychecker.utils import log from libcpychecker.refcounts import check_refcounts, get_traces diff --git a/libcpychecker/diagnostics.py b/libcpychecker/diagnostics.py index 18d8a1b..e4aa361 100644 --- a/libcpychecker/diagnostics.py +++ b/libcpychecker/diagnostics.py @@ -23,7 +23,7 @@ HTML visualizations import gcc from gccutils import get_src_for_loc from libcpychecker.visualizations import HtmlRenderer -from libcpychecker.PyArg_ParseTuple import log +from libcpychecker.utils import log class Annotator: """ diff --git a/libcpychecker/formatstrings.py b/libcpychecker/formatstrings.py new file mode 100644 index 0000000..4a048a5 --- /dev/null +++ b/libcpychecker/formatstrings.py @@ -0,0 +1,434 @@ +# 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/>. + +import sys + +from gccutils import get_src_for_loc, get_global_typedef + +from libcpychecker.types import * +from libcpychecker.utils import log + +const_correctness = True + +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_hash_size_type(with_size_t): + # Was PY_SSIZE_T_CLEAN defined? + if with_size_t: + return get_Py_ssize_t() + else: + return gcc.Type.int() + +class NullPointer: + # Dummy value, for pointer arguments that can legitimately be NULL + def describe(self): + return 'NULL' + +class CExtensionError(Exception): + # Base class for errors discovered by static analysis in C extension code + pass + +class FormatStringError(CExtensionError): + def __init__(self, fmt_string): + self.fmt_string = fmt_string + +class UnknownFormatChar(FormatStringError): + def __init__(self, fmt_string, ch): + FormatStringError.__init__(self, fmt_string) + self.ch = ch + + def __str__(self): + return "unknown format char in \"%s\": '%s'" % (self.fmt_string, self.ch) + +class UnhandledCode(UnknownFormatChar): + def __str__(self): + return "unhandled format code in \"%s\": '%s' (FIXME)" % (self.fmt_string, self.ch) + + +class MismatchedParentheses(FormatStringError): + def __str__(self): + return "mismatched parentheses in format string \"%s\"" % (self.fmt_string, ) + +class ParsedFormatStringError(FormatStringError): + def __init__(self, funcname, fmt): + FormatStringError.__init__(self, fmt.fmt_string) + self.funcname = funcname + self.fmt = fmt + +class FormatUnit: + """ + One fragment of the string arg to PyArg_ParseTuple and friends + """ + def __init__(self, code): + self.code = code + + def get_expected_types(self): + # Return a list of the types expected for this format unit, + # either as gcc.Type instances, or as instances of AwkwardType + raise NotImplementedError + +class ConcreteUnit(FormatUnit): + """ + The common case: a fragment of a format string that corresponds to a + pre-determined list of types (often just a single element) + """ + def __init__(self, code, expected_types): + FormatUnit.__init__(self, code) + self.expected_types = expected_types + + def get_expected_types(self): + return self.expected_types + + def __repr__(self): + return 'ConcreteUnit(%r,%r)' % (self.code, self.expected_types) + +class AwkwardType: + """ + Base class for expected types within a format unit that need special + handling (e.g. for "O!" and "O&") + """ + def is_compatible(self, actual_type, actual_arg): + raise NotImplementedError + + def describe(self): + raise NotImplementedError + +class ParsedFormatString: + """ + Python class representing the result of parsing a format string + """ + def __init__(self, fmt_string): + self.fmt_string = fmt_string + self.args = [] + + def __repr__(self): + return ('%s(fmt_string=%r, args=%r)' + % (self.__class__.__name__, self.fmt_string, self.args)) + +class WrongNumberOfVars(ParsedFormatStringError): + def __init__(self, funcname, fmt, varargs): + ParsedFormatStringError.__init__(self, funcname, fmt) + self.varargs = varargs + + def __str__(self): + 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 + +class NotEnoughVars(WrongNumberOfVars): + def _get_desc_prefix(self): + return 'Not enough arguments' + +class TooManyVars(WrongNumberOfVars): + def _get_desc_prefix(self): + return 'Too many arguments' + +class MismatchingType(ParsedFormatStringError): + def __init__(self, funcname, fmt, arg_num, arg_fmt_string, exp_type, vararg): + super(self.__class__, self).__init__(funcname, fmt) + self.arg_num = arg_num + self.arg_fmt_string = arg_fmt_string + self.exp_type = exp_type + self.vararg = vararg + + def extra_info(self): + def _describe_vararg(va): + result = '"%s"' % va.type + if hasattr(va, 'operand'): + result += describe_precision(va.operand.type) + return result + + 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)) + + def __str__(self): + return ('Mismatching type in call to %s with format code "%s"' + % (self.funcname, self.fmt.fmt_string)) + +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, NullPointer): + return t.describe() + if isinstance(t, tuple): + result = 'one of ' + ' or '.join([describe_type(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 + +def compatible_type(exp_type, actual_type, actualarg=None): + 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)) + log('actualarg: %s (%r)', actualarg, actualarg) + + # 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, actualarg): + return True + # Didn't match any of them: + return False + + # Support the "O!" and "O&" converter codes: + if isinstance(exp_type, AwkwardType): + return exp_type.is_compatible(actual_type, actualarg) + + # Support the codes that can accept NULL: + if isinstance(exp_type, NullPointer): + if isinstance(actual_type, gcc.PointerType): + if isinstance(actual_type.dereference, gcc.VoidType): + # We have a (void*), double-check that it's actually NULL: + if actualarg: + if isinstance(actualarg, gcc.IntegerCst): + if actualarg.constant == 0: + # We have NULL: + return True + 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) + + # Try direct comparison: + if actual_type == exp_type: + return True + + # Sometimes we get the typedef rather than the type, for both exp and + # actual. Compare using the actual types, but report using the typedefs + # so that we can report that e.g. + # PyObject * * + # was expected, rather than: + # struct PyObject * * + if isinstance(exp_type, gcc.TypeDecl): + if compatible_type(exp_type.type, actual_type): + return True + + if isinstance(actual_type, gcc.TypeDecl): + if compatible_type(exp_type, actual_type.type): + return True + + # Dereference for pointers (and ptrs to ptrs etc): + if isinstance(actual_type, gcc.PointerType) and isinstance(exp_type, gcc.PointerType): + if compatible_type(actual_type.dereference, exp_type.dereference): + return True + + # Don't be too fussy about typedefs to integer types + # For instance: + # typedef unsigned PY_LONG_LONG gdb_py_ulongest; + # gives a different IntegerType instance to that of + # gcc.Type.long_long().unsigned_equivalent + # As long as the size, signedness etc are the same, let it go + if isinstance(actual_type, gcc.IntegerType) and isinstance(exp_type, gcc.IntegerType): + def compare_int_types(): + for attr in ('precision', 'unsigned', + 'const', 'volatile', 'restrict'): + if getattr(actual_type, attr) != getattr(exp_type, attr): + return False + return True + if compare_int_types(): + return True + + return False + +def check_pyargs(fun): + from libcpychecker.PyArg_ParseTuple import PyArgParseFmt + from libcpychecker.Py_BuildValue import PyBuildValueFmt + + def get_format_string(stmt, format_idx): + fmt_code = stmt.args[format_idx] + # We can only cope with the easy case, when it's a AddrExpr(StringCst()) + # i.e. a reference to a string constant, i.e. a string literal in the C + # source: + if isinstance(fmt_code, gcc.AddrExpr): + operand = fmt_code.operand + if isinstance(operand, gcc.StringCst): + return operand.constant + + def check_keyword_array(stmt, idx): + keywords = stmt.args[idx] + if isinstance(keywords, gcc.AddrExpr): + operand = keywords.operand + if isinstance(operand, gcc.VarDecl): + # Caveat: "initial" will only be set up on the VarDecl of a + # global variable, or a "static" variable in function scope; + # for other local variables we appear to need to track the + # gimple statements to get the value at the callsite + initial = operand.initial + if isinstance(initial, gcc.Constructor): + elements = [None] * len(initial.elements) + for elt in initial.elements: + (num, contents) = elt + elt_idx = num.constant + if isinstance(contents, gcc.NopExpr): + contents = contents.operand + if isinstance(contents, gcc.AddrExpr): + contents = contents.operand + if isinstance(contents, gcc.StringCst): + elements[elt_idx] = contents.constant + elif isinstance(contents, gcc.IntegerCst): + elements[elt_idx] = contents.constant + if elements[-1] != 0: + gcc.permerror(stmt.loc, 'keywords to PyArg_ParseTupleAndKeywords are not NULL-terminated') + i = 0 + for elt in elements[0:-1]: + if not elt: + gcc.permerror(stmt.loc, 'keyword argument %d missing in PyArg_ParseTupleAndKeywords call' % i) + i = i + 1 + + def check_callsite(stmt, parser, funcname, format_idx, varargs_idx, with_size_t): + log('got call at %s', stmt.loc) + log(get_src_for_loc(stmt.loc)) + # log('stmt: %r %s', (stmt, stmt)) + # log('args: %r', stmt.args) + # for arg in stmt.args: + # # log(' arg: %s %r', (arg, arg)) + + + # We expect the following args: + # args[0]: PyObject *input_tuple + # args[1]: char * format + # args[2...]: output pointers + + if len(stmt.args) > 1: + fmt_string = get_format_string(stmt, format_idx) + if fmt_string: + log('fmt_string: %r', fmt_string) + + loc = stmt.loc + + # Figure out expected types, based on the format string... + try: + fmt = parser.from_string(fmt_string, with_size_t) + except FormatStringError: + exc = sys.exc_info()[1] + gcc.permerror(stmt.loc, str(exc)) + return + log('fmt: %r', fmt.args) + + exp_types = list(fmt.iter_exp_types()) + log('exp_types: %r', exp_types) + + # ...then compare them against the actual types: + varargs = stmt.args[varargs_idx:] + # log('varargs: %r', varargs) + if len(varargs) < len(exp_types): + gcc.permerror(loc, str(NotEnoughVars(funcname, fmt, varargs))) + return + + if len(varargs) > len(exp_types): + gcc.permerror(loc, str(TooManyVars(funcname, fmt, varargs))) + return + + for index, ((exp_arg, exp_type), vararg) in enumerate(zip(exp_types, varargs)): + if not compatible_type(exp_type, vararg.type, actualarg=vararg): + err = MismatchingType(funcname, fmt, + index + varargs_idx + 1, + exp_arg.code, exp_type, vararg) + if hasattr(vararg, 'location'): + loc = vararg.location + else: + loc = stmt.loc + gcc.permerror(loc, + str(err)) + sys.stderr.write(err.extra_info()) + + def maybe_check_callsite(stmt): + if stmt.fndecl: + # If "PY_SSIZE_T_CLEAN" is defined before #include <Python.h>, then + # the preprocessor is actually turning these into "_SizeT"-suffixed + # variants, which handle some format codes differently + + # FIXME: should we report the name as seen by the compiler? + # It doesn't appear in the CPython API docs + + if stmt.fndecl.name == 'PyArg_ParseTuple': + check_callsite(stmt, + PyArgParseFmt, + 'PyArg_ParseTuple', + 1, 2, False) + elif stmt.fndecl.name == '_PyArg_ParseTuple_SizeT': + check_callsite(stmt, + PyArgParseFmt, + 'PyArg_ParseTuple', + 1, 2, True) + elif stmt.fndecl.name == 'PyArg_ParseTupleAndKeywords': + check_keyword_array(stmt, 3) + check_callsite(stmt, + PyArgParseFmt, + 'PyArg_ParseTupleAndKeywords', + 2, 4, False) + elif stmt.fndecl.name == '_PyArg_ParseTupleAndKeywords_SizeT': + check_keyword_array(stmt, 3) + check_callsite(stmt, + PyArgParseFmt, + 'PyArg_ParseTupleAndKeywords', + 2, 4, True) + + if fun.cfg: + for bb in fun.cfg.basic_blocks: + if isinstance(bb.gimple, list): + for stmt in bb.gimple: + if stmt.loc: + gcc.set_location(stmt.loc) + if isinstance(stmt, gcc.GimpleCall): + maybe_check_callsite(stmt)

1 0

[gcc-python-plugin] cpychecker: remove a couple of long-redundant disabled selftests
by David Hugh Malcolm 06 Sep '11

06 Sep '11

commit 1b36288f215072f52df01f04ae9f05f9e47b0018 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Tue Sep 6 17:34:43 2011 -0400 cpychecker: remove a couple of long-redundant disabled selftests testcpychecker.py | 59 ----------------------------------------------------- 1 files changed, 0 insertions(+), 59 deletions(-) --- diff --git a/testcpychecker.py b/testcpychecker.py index d6d0659..33c4c7e 100644 --- a/testcpychecker.py +++ b/testcpychecker.py @@ -474,64 +474,5 @@ class PyArg_ParseTupleAndKeywordsTests(PyArg_ParseTupleTests): '}\n') % locals() return src, function_name -(a)unittest.skip("Refcount tracker doesn't yet work") -class RefcountErrorTests(AnalyzerTests): - def add_method_table(self, cu, fn_name): - methods = PyMethodTable('test_methods', - [PyMethodDef('test_method', fn_name, - METH_VARARGS, None)]) - cu.add_defn(methods.c_defn()) - return methods - - def add_module(self, sm, methods): - sm.add_module_init('buggy', modmethods=methods, moddoc=None) - - def make_mod_method(self, function_name, body): - sm = SimpleModule() - sm.cu.add_defn( - 'int val;\n' - 'PyObject *\n' - '%(function_name)s(PyObject *self, PyObject *args)\n' % locals() - +'{\n' - + body - + '}\n') - methods = self.add_method_table(sm.cu, function_name) - self.add_module(sm, methods) - return sm - - def test_missing_decref(self): - sm = self.make_mod_method('missing_decref', - ' PyObject *list;\n' - ' PyObject *item;\n' - ' list = PyList_New(1);\n' - ' if (!list)\n' - ' return NULL;\n' - ' item = PyLong_FromLong(42);\n' - ' /* This error handling is incorrect: it\'s missing an\n' - ' invocation of Py_DECREF(list): */\n' - ' if (!item)\n' - ' return NULL;\n' - ' PyList_SET_ITEM(list, 0, item);\n' - ' return list;\n') - experr = ('$(SRCFILE):21:10: error: leak of PyObject* reference acquired at call to PyList_New at $(SRCFILE):21 [-fpermissive]\n' - ' $(SRCFILE):22: taking False path at if (!list)\n' - ' $(SRCFILE):24: reaching here item = PyLong_FromLong(42);\n' - ' $(SRCFILE):27: taking True path at if (!item)\n' - ' $(SRCFILE):21: returning 0\n') - self.assertFindsError(sm, experr) - -# Test disabled for now: we can't easily import this under gcc anymore: -class TestArgParsing: # (unittest.TestCase): - def assert_args(self, arg_str, exp_result): - result = get_types(None, arg_str) - self.assertEquals(result, exp_result) - - def test_fcntlmodule_fcntl_flock(self): - # FIXME: somewhat broken, we can't know what the converter callback is - self.assert_args("O&i:flock", - ['int ( PyObject * object , int * target )', - 'int *', - 'int *']) - if __name__ == '__main__': unittest.main()

1 0

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

06 Sep '11

commit ea44c9be7665aaf340f4e42121f569ac1e3f17b9 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Tue Sep 6 17:22:50 2011 -0400 cpychecker: implement PyStructSequence_InitType libcpychecker/refcounts.py | 7 +++++++ 1 files changed, 7 insertions(+), 0 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index f86e0a7..232b7d2 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -1396,6 +1396,13 @@ class MyState(State): ######################################################################## # PyStructSequence_* ######################################################################## + def impl_PyStructSequence_InitType(self, stmt): + # void PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc) + # + # Implemented in Objects/structseq.c + # For now, treat it as a no-op: + return [self.mktrans_nop(stmt, 'PyStructSequence_InitType')] + def impl_PyStructSequence_New(self, stmt): # Declared in structseq.h as: # PyAPI_FUNC(PyObject *) PyStructSequence_New(PyTypeObject* type);

1 0

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

06 Sep '11

commit 037c0f9dcceea8940a07999d1f81719aab537a18 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Tue Sep 6 15:18:43 2011 -0400 cpychecker: implement PyImport_ImportModule libcpychecker/refcounts.py | 6 ++++++ 1 files changed, 6 insertions(+), 0 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index c400533..f86e0a7 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -959,6 +959,12 @@ class MyState(State): # have been called yet, in any case) return self.make_transitions_for_fncall(stmt, s_success, s_failure) + def impl_PyImport_ImportModule(self, stmt): + # http://docs.python.org/c-api/import.html#PyImport_ImportModule + newobj, t_success, t_failure = self.impl_object_ctor(stmt, + 'PyModuleObject', 'PyModule_Type') + return [t_success, t_failure] + ######################################################################## # Py_Initialize* ########################################################################

1 0

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

06 Sep '11

commit b2780f481ec22fc7de131c74a8d4de4aed5da6a2 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Tue Sep 6 15:18:24 2011 -0400 cpychecker: implement PyEval_InitThreads libcpychecker/refcounts.py | 8 ++++++++ 1 files changed, 8 insertions(+), 0 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index 1918736..c400533 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -933,6 +933,14 @@ class MyState(State): return [t_next] ######################################################################## + # PyEval_InitThreads() + ######################################################################## + def impl_PyEval_InitThreads(self, stmt): + # http://docs.python.org/c-api/init.html#PyEval_InitThreads + # For now, treat it as a no-op: + return [self.mktrans_nop(stmt, 'PyEval_InitThreads')] + + ######################################################################## # Py_Finalize() ######################################################################## def impl_Py_Finalize(self, stmt):

1 0

[gcc-python-plugin] cpychecker: bulletproof impl_object_ctor against invocations that don't capture the return value
by David Hugh Malcolm 06 Sep '11

06 Sep '11

commit 37b499cd62c29cb01e72870ee2990be760d92696 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Tue Sep 6 15:17:37 2011 -0400 cpychecker: bulletproof impl_object_ctor against invocations that don't capture the return value libcpychecker/refcounts.py | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index 57685d7..1918736 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -371,6 +371,7 @@ class MyState(State): check_isinstance(typeobjdecl, gcc.VarDecl) fnname = stmt.fn.operand.name + returntype = stmt.fn.type.dereference.type # (the region hierarchy is shared by all states, so we can get the # var region from "self", rather than "success") @@ -383,7 +384,7 @@ class MyState(State): '%s() succeeds' % fnname) # The "failure" case: t_failure = self.mktrans_assignment(stmt.lhs, - ConcreteValue(stmt.lhs.type, stmt.loc, 0), + ConcreteValue(returntype, stmt.loc, 0), '%s() fails' % fnname) t_failure.dest.set_exception('PyExc_MemoryError') return (nonnull, t_success, t_failure)

1 0

[gcc-python-plugin] cpychecker: implement PyRun_SimpleFileExFlags and PyRun_SimpleStringFlags
by David Hugh Malcolm 06 Sep '11

06 Sep '11

commit 122357293f1767435387731cfc5d0e6ba65c9753 Author: David Malcolm <dmalcolm(a)redhat.com> Date: Tue Sep 6 14:51:55 2011 -0400 cpychecker: implement PyRun_SimpleFileExFlags and PyRun_SimpleStringFlags libcpychecker/refcounts.py | 18 ++++++++++++++++++ 1 files changed, 18 insertions(+), 0 deletions(-) --- diff --git a/libcpychecker/refcounts.py b/libcpychecker/refcounts.py index c6decd1..57685d7 100644 --- a/libcpychecker/refcounts.py +++ b/libcpychecker/refcounts.py @@ -1296,6 +1296,24 @@ class MyState(State): return [t_success, t_failure] ######################################################################## + # PyRun_* + ######################################################################## + def impl_PyRun_SimpleFileExFlags(self, stmt): + # http://docs.python.org/c-api/veryhigh.html#PyRun_SimpleFileExFlags + s_success = self.mkstate_concrete_return_of(stmt, 0) + s_failure = self.mkstate_concrete_return_of(stmt, -1) + # (no way to get the exception on failure) + # (FIXME: handle the potential autoclosing of the FILE*) + return self.make_transitions_for_fncall(stmt, s_success, s_failure) + + def impl_PyRun_SimpleStringFlags(self, stmt): + # http://docs.python.org/c-api/veryhigh.html#PyRun_SimpleStringFlags + s_success = self.mkstate_concrete_return_of(stmt, 0) + s_failure = self.mkstate_concrete_return_of(stmt, -1) + # (no way to get the exception on failure) + return self.make_transitions_for_fncall(stmt, s_success, s_failure) + + ######################################################################## # PyString_* ######################################################################## def impl_PyString_AsString(self, stmt):

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

gcc-python-plugin-commits September 2011