gdb/contrib/cleanup_check.py

gdb/contrib/cleanup_check.py - gdb

Global variables defined

destructor_names
logging
ps
show_cfg
special_names
want_raii_info
Functions defined

is_cleanup_type
is_constructor
is_destructor
log
needs_special_treatment
Source code

#   Copyright 2013-2015 Free Software Foundation, 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 gcc

import gccutils

import sys



‌want_raii_info = False



‌logging = False

‌show_cfg = False



‌def log(msg, indent=0):

    global logging

    if logging:

        sys.stderr.write('%s%s\n' % ('  ' * indent, msg))

        sys.stderr.flush()



‌def is_cleanup_type(return_type):

    if not isinstance(return_type, gcc.PointerType):

        return False

    if not isinstance(return_type.dereference, gcc.RecordType):

        return False

    if str(return_type.dereference.name) == 'cleanup':

        return True

    return False



‌def is_constructor(decl):

    "Return True if the function DECL is a cleanup constructor; False otherwise"

    return is_cleanup_type(decl.type.type) and (not decl.name or str(decl.name) != 'make_final_cleanup')



‌destructor_names = set(['do_cleanups', 'discard_cleanups'])



‌def is_destructor(decl):

    return decl.name in destructor_names



# This list is just much too long... we should probably have an

# attribute instead.

‌special_names = set(['do_final_cleanups', 'discard_final_cleanups',

                     'save_cleanups', 'save_final_cleanups',

                     'restore_cleanups', 'restore_final_cleanups',

                     'exceptions_state_mc_init',

                     'make_my_cleanup2', 'make_final_cleanup', 'all_cleanups',

                     'save_my_cleanups', 'quit_target'])



‌def needs_special_treatment(decl):

    return decl.name in special_names



# Sometimes we need a new placeholder object that isn't the same as

# anything else.

class Dummy(object):

    def __init__(self, location):

        self.location = location



# A wrapper for a cleanup which has been assigned to a variable.

# This holds the variable and the location.

class Cleanup(object):

    def __init__(self, var, location):

        self.var = var

        self.location = location



# A class representing a master cleanup.  This holds a stack of

# cleanup objects and supports a merging operation.

class MasterCleanup(object):

    # Create a new MasterCleanup object.  OTHER, if given, is a

    # MasterCleanup object to copy.

    def __init__(self, other = None):

        # 'cleanups' is a list of cleanups.  Each element is either a

        # Dummy, for an anonymous cleanup, or a Cleanup, for a cleanup

        # which was assigned to a variable.

        if other is None:

            self.cleanups = []

            self.aliases = {}

        else:

            self.cleanups = other.cleanups[:]

            self.aliases = dict(other.aliases)



    def compare_vars(self, definition, argument):

        if definition == argument:

            return True

        if argument in self.aliases:

            argument = self.aliases[argument]

        if definition in self.aliases:

            definition = self.aliases[definition]

        return definition == argument



    def note_assignment(self, lhs, rhs):

        log('noting assignment %s = %s' % (lhs, rhs), 4)

        self.aliases[lhs] = rhs



    # Merge with another MasterCleanup.

    # Returns True if this resulted in a change to our state.

    def merge(self, other):

        # We do explicit iteration like this so we can easily

        # update the list after the loop.

        counter = -1

        found_named = False

        for counter in range(len(self.cleanups) - 1, -1, -1):

            var = self.cleanups[counter]

            log('merge checking %s' % var, 4)

            # Only interested in named cleanups.

            if isinstance(var, Dummy):

                log('=> merge dummy', 5)

                continue

            # Now see if VAR is found in OTHER.

            if other._find_var(var.var) >= 0:

                log ('=> merge found', 5)

                break

            log('=>merge not found', 5)

            found_named = True

        if found_named and counter < len(self.cleanups) - 1:

            log ('merging to %d' % counter, 4)

            if counter < 0:

                self.cleanups = []

            else:

                self.cleanups = self.cleanups[0:counter]

            return True

        # If SELF is empty but OTHER has some cleanups, then consider

        # that a change as well.

        if len(self.cleanups) == 0 and len(other.cleanups) > 0:

            log('merging non-empty other', 4)

            self.cleanups = other.cleanups[:]

            return True

        return False



    # Push a new constructor onto our stack.  LHS is the

    # left-hand-side of the GimpleCall statement.  It may be None,

    # meaning that this constructor's value wasn't used.

    def push(self, location, lhs):

        if lhs is None:

            obj = Dummy(location)

        else:

            obj = Cleanup(lhs, location)

        log('pushing %s' % lhs, 4)

        idx = self._find_var(lhs)

        if idx >= 0:

            gcc.permerror(location, 'reassigning to known cleanup')

            gcc.inform(self.cleanups[idx].location,

                       'previous assignment is here')

        self.cleanups.append(obj)



    # A helper for merge and pop that finds BACK_TO in self.cleanups,

    # and returns the index, or -1 if not found.

    def _find_var(self, back_to):

        for i in range(len(self.cleanups) - 1, -1, -1):

            if isinstance(self.cleanups[i], Dummy):

                continue

            if self.compare_vars(self.cleanups[i].var, back_to):

                return i

        return -1



    # Pop constructors until we find one matching BACK_TO.

    # This is invoked when we see a do_cleanups call.

    def pop(self, location, back_to):

        log('pop:', 4)

        i = self._find_var(back_to)

        if i >= 0:

            self.cleanups = self.cleanups[0:i]

        else:

            gcc.permerror(location, 'destructor call with unknown argument')



    # Check whether ARG is the current master cleanup.  Return True if

    # all is well.

    def verify(self, location, arg):

        log('verify %s' % arg, 4)

        return (len(self.cleanups) > 0

                and not isinstance(self.cleanups[0], Dummy)

                and self.compare_vars(self.cleanups[0].var, arg))



    # Check whether SELF is empty.

    def isempty(self):

        log('isempty: len = %d' % len(self.cleanups), 4)

        return len(self.cleanups) == 0



    # Emit informational warnings about the cleanup stack.

    def inform(self):

        for item in reversed(self.cleanups):

            gcc.inform(item.location, 'leaked cleanup')



class CleanupChecker:

    def __init__(self, fun):

        self.fun = fun

        self.seen_edges = set()

        self.bad_returns = set()



        # This maps BB indices to a list of master cleanups for the

        # BB.

        self.master_cleanups = {}



    # Pick a reasonable location for the basic block BB.

    def guess_bb_location(self, bb):

        if isinstance(bb.gimple, list):

            for stmt in bb.gimple:

                if stmt.loc:

                    return stmt.loc

        return self.fun.end



    # Compute the master cleanup list for BB.

    # Modifies MASTER_CLEANUP in place.

    def compute_master(self, bb, bb_from, master_cleanup):

        if not isinstance(bb.gimple, list):

            return

        curloc = self.fun.end

        for stmt in bb.gimple:

            if stmt.loc:

                curloc = stmt.loc

            if isinstance(stmt, gcc.GimpleCall) and stmt.fndecl:

                if is_constructor(stmt.fndecl):

                    log('saw constructor %s in bb=%d' % (str(stmt.fndecl), bb.index), 2)

                    self.cleanup_aware = True

                    master_cleanup.push(curloc, stmt.lhs)

                elif is_destructor(stmt.fndecl):

                    if str(stmt.fndecl.name) != 'do_cleanups':

                        self.only_do_cleanups_seen = False

                    log('saw destructor %s in bb=%d, bb_from=%d, argument=%s'

                        % (str(stmt.fndecl.name), bb.index, bb_from, str(stmt.args[0])),

                        2)

                    master_cleanup.pop(curloc, stmt.args[0])

                elif needs_special_treatment(stmt.fndecl):

                    pass

                    # gcc.permerror(curloc, 'function needs special treatment')

            elif isinstance(stmt, gcc.GimpleAssign):

                if isinstance(stmt.lhs, gcc.VarDecl) and isinstance(stmt.rhs[0], gcc.VarDecl):

                    master_cleanup.note_assignment(stmt.lhs, stmt.rhs[0])

            elif isinstance(stmt, gcc.GimpleReturn):

                if self.is_constructor:

                    if not master_cleanup.verify(curloc, stmt.retval):

                        gcc.permerror(curloc,

                                      'constructor does not return master cleanup')

                elif not self.is_special_constructor:

                    if not master_cleanup.isempty():

                        if curloc not in self.bad_returns:

                            gcc.permerror(curloc, 'cleanup stack is not empty at return')

                            self.bad_returns.add(curloc)

                            master_cleanup.inform()



    # Traverse a basic block, updating the master cleanup information

    # and propagating to other blocks.

    def traverse_bbs(self, edge, bb, bb_from, entry_master):

        log('traverse_bbs %d from %d' % (bb.index, bb_from), 1)



        # Propagate the entry MasterCleanup though this block.

        master_cleanup = MasterCleanup(entry_master)

        self.compute_master(bb, bb_from, master_cleanup)



        modified = False

        if bb.index in self.master_cleanups:

            # Merge the newly-computed MasterCleanup into the one we

            # have already computed.  If this resulted in a

            # significant change, then we need to re-propagate.

            modified = self.master_cleanups[bb.index].merge(master_cleanup)

        else:

            self.master_cleanups[bb.index] = master_cleanup

            modified = True



        # EDGE is None for the entry BB.

        if edge is not None:

            # If merging cleanups caused a change, check to see if we

            # have a bad loop.

            if edge in self.seen_edges:

                # This error doesn't really help.

                # if modified:

                #     gcc.permerror(self.guess_bb_location(bb),

                #                   'invalid cleanup use in loop')

                return

            self.seen_edges.add(edge)



        if not modified:

            return



        # Now propagate to successor nodes.

        for edge in bb.succs:

            self.traverse_bbs(edge, edge.dest, bb.index, master_cleanup)



    def check_cleanups(self):

        if not self.fun.cfg or not self.fun.decl:

            return 'ignored'

        if is_destructor(self.fun.decl):

            return 'destructor'

        if needs_special_treatment(self.fun.decl):

            return 'special'



        self.is_constructor = is_constructor(self.fun.decl)

        self.is_special_constructor = not self.is_constructor and str(self.fun.decl.name).find('with_cleanup') > -1

        # Yuck.

        if str(self.fun.decl.name) == 'gdb_xml_create_parser_and_cleanup_1':

            self.is_special_constructor = True



        if self.is_special_constructor:

            gcc.inform(self.fun.start, 'function %s is a special constructor' % (self.fun.decl.name))



        # If we only see do_cleanups calls, and this function is not

        # itself a constructor, then we can convert it easily to RAII.

        self.only_do_cleanups_seen = not self.is_constructor

        # If we ever call a constructor, then we are "cleanup-aware".

        self.cleanup_aware = False



        entry_bb = self.fun.cfg.entry

        master_cleanup = MasterCleanup()

        self.traverse_bbs(None, entry_bb, -1, master_cleanup)

        if want_raii_info and self.only_do_cleanups_seen and self.cleanup_aware:

            gcc.inform(self.fun.decl.location,

                       'function %s could be converted to RAII' % (self.fun.decl.name))

        if self.is_constructor:

            return 'constructor'

        return 'OK'



class CheckerPass(gcc.GimplePass):

    def execute(self, fun):

        if fun.decl:

            log("Starting " + fun.decl.name)

            if show_cfg:

                dot = gccutils.cfg_to_dot(fun.cfg, fun.decl.name)

                gccutils.invoke_dot(dot, name=fun.decl.name)

        checker = CleanupChecker(fun)

        what = checker.check_cleanups()

        if fun.decl:

            log(fun.decl.name + ': ' + what, 2)



‌ps = CheckerPass(name = 'check-cleanups')

# We need the cfg, but we want a relatively high-level Gimple.

ps.register_after('cfg')