Subversion Repositories openrisc_me

# Copyright (C) 2009, 2010 Free Software Foundation, Inc.

#

# This file is part of GDB.

#

# This program 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 gdb

import os.path

class TypeFlag:

    """A class that allows us to store a flag name, its short name,

    and its value.

    In the GDB sources, struct type has a component called instance_flags

    in which the value is the addition of various flags.  These flags are

    defined by two enumerates: type_flag_value, and type_instance_flag_value.

    This class helps us recreate a list with all these flags that is

    easy to manipulate and sort.  Because all flag names start with either

    TYPE_FLAG_ or TYPE_INSTANCE_FLAG_, a short_name attribute is provided

    that strips this prefix.

    ATTRIBUTES

      name:  The enumeration name (eg: "TYPE_FLAG_UNSIGNED").

      value: The associated value.

      short_name: The enumeration name, with the suffix stripped.

    """

    def __init__(self, name, value):

        self.name = name

        self.value = value

        self.short_name = name.replace("TYPE_FLAG_", '')

        if self.short_name == name:

            self.short_name = name.replace("TYPE_INSTANCE_FLAG_", '')

    def __cmp__(self, other):

        """Sort by value order."""

        return self.value.__cmp__(other.value)

# A list of all existing TYPE_FLAGS_* and TYPE_INSTANCE_FLAGS_*

# enumerations, stored as TypeFlags objects.  Lazy-initialized.

TYPE_FLAGS = None

class TypeFlagsPrinter:

    """A class that prints a decoded form of an instance_flags value.

    This class uses a global named TYPE_FLAGS, which is a list of

    all defined TypeFlag values.  Using a global allows us to compute

    this list only once.

    This class relies on a couple of enumeration types being defined.

    If not, then printing of the instance_flag is going to be degraded,

    but it's not a fatal error.

    """

    def __init__(self, val):

        self.val = val

    def __str__(self):

        global TYPE_FLAGS

        if TYPE_FLAGS is None:

            self.init_TYPE_FLAGS()

        if not self.val:

            return "0"

        if TYPE_FLAGS:

            flag_list = [flag.short_name for flag in TYPE_FLAGS

                         if self.val & flag.value]

        else:

            flag_list = ["???"]

        return "0x%x [%s]" % (self.val, "|".join(flag_list))

    def init_TYPE_FLAGS(self):

        """Initialize the TYPE_FLAGS global as a list of TypeFlag objects.

        This operation requires the search of a couple of enumeration types.

        If not found, a warning is printed on stdout, and TYPE_FLAGS is

        set to the empty list.

        The resulting list is sorted by increasing value, to facilitate

        printing of the list of flags used in an instance_flags value.

        """

        global TYPE_FLAGS

        TYPE_FLAGS = []

        try:

            flags = gdb.lookup_type("enum type_flag_value")

        except:

            print "Warning: Cannot find enum type_flag_value type."

            print "         `struct type' pretty-printer will be degraded"

            return

        try:

            iflags = gdb.lookup_type("enum type_instance_flag_value")

        except:

            print "Warning: Cannot find enum type_instance_flag_value type."

            print "         `struct type' pretty-printer will be degraded"

            return

        # Note: TYPE_FLAG_MIN is a duplicate of TYPE_FLAG_UNSIGNED,

        # so exclude it from the list we are building.

        TYPE_FLAGS = [TypeFlag(field.name, field.bitpos)

                      for field in flags.fields()

                      if field.name != 'TYPE_FLAG_MIN']

        TYPE_FLAGS += [TypeFlag(field.name, field.bitpos)

                       for field in iflags.fields()]

        TYPE_FLAGS.sort()

class StructTypePrettyPrinter:

    """Pretty-print an object of type struct type"""

    def __init__(self, val):

        self.val = val

    def to_string(self):

        fields = []

        fields.append("pointer_type = %s" % self.val['pointer_type'])

        fields.append("reference_type = %s" % self.val['reference_type'])

        fields.append("chain = %s" % self.val['reference_type'])

        fields.append("instance_flags = %s"

                      % TypeFlagsPrinter(self.val['instance_flags']))

        fields.append("length = %d" % self.val['length'])

        fields.append("main_type = %s" % self.val['main_type'])

        return "\n{" + ",\n ".join(fields) + "}"

class StructMainTypePrettyPrinter:

    """Pretty-print an objet of type main_type"""

    def __init__(self, val):

        self.val = val

    def flags_to_string(self):

        """struct main_type contains a series of components that

        are one-bit ints whose name start with "flag_".  For instance:

        flag_unsigned, flag_stub, etc.  In essence, these components are

        really boolean flags, and this method prints a short synthetic

        version of the value of all these flags.  For instance, if

        flag_unsigned and flag_static are the only components set to 1,

        this function will return "unsigned|static".

        """

        fields = [field.name.replace("flag_", "")

                  for field in self.val.type.fields()

                  if field.name.startswith("flag_")

                     and self.val[field.name]]

        return "|".join(fields)

    def owner_to_string(self):

        """Return an image of component "owner".

        """

        if self.val['flag_objfile_owned'] != 0:

            return "%s (objfile)" % self.val['owner']['objfile']

        else:

            return "%s (gdbarch)" % self.val['owner']['gdbarch']

    def struct_field_location_img(self, field_val):

        """Return an image of the loc component inside the given field

        gdb.Value.

        """

        loc_val = field_val['loc']

        loc_kind = str(field_val['loc_kind'])

        if loc_kind == "FIELD_LOC_KIND_BITPOS":

            return 'bitpos = %d' % loc_val['bitpos']

        elif loc_kind == "FIELD_LOC_KIND_PHYSADDR":

            return 'physaddr = 0x%x' % loc_val['physaddr']

        elif loc_kind == "FIELD_LOC_KIND_PHYSNAME":

            return 'physname = %s' % loc_val['physname']

        elif loc_kind == "FIELD_LOC_KIND_DWARF_BLOCK":

            return 'dwarf_block = %s' % loc_val['dwarf_block']

        else:

            return 'loc = ??? (unsupported loc_kind value)'

    def struct_field_img(self, fieldno):

        """Return an image of the main_type field number FIELDNO.

        """

        f = self.val['flds_bnds']['fields'][fieldno]

        label = "field[%d]:" % fieldno

        if f['artificial']:

            label += " (artificial)"

        fields = []

        fields.append("name = %s" % f['name'])

        fields.append("type = %s" % f['type'])

        fields.append("loc_kind = %s" % f['loc_kind'])

        fields.append("bitsize = %d" % f['bitsize'])

        fields.append(self.struct_field_location_img(f))

        return label + "\n" + "  {" + ",\n   ".join(fields) + "}"

    def bounds_img(self):

        """Return an image of the main_type bounds.

        """

        b = self.val['flds_bnds']['bounds'].dereference()

        low = str(b['low'])

        if b['low_undefined'] != 0:

            low += " (undefined)"

        high = str(b['high'])

        if b['high_undefined'] != 0:

            high += " (undefined)"

        return "bounds = {%s, %s}" % (low, high)

    def type_specific_img(self):

        """Return a string image of the main_type type_specific union.

        Only the relevant component of that union is printed (based on

        the value of the type_specific_kind field.

        """

        type_specific_kind = str(self.val['type_specific_field'])

        type_specific = self.val['type_specific']

        if type_specific_kind == "TYPE_SPECIFIC_NONE":

            img = 'type_specific_field = %s' % type_specific_kind

        elif type_specific_kind == "TYPE_SPECIFIC_CPLUS_STUFF":

            img = "cplus_stuff = %s" % type_specific['cplus_stuff']

        elif type_specific_kind == "TYPE_SPECIFIC_GNAT_STUFF":

            img = ("gnat_stuff = {descriptive_type = %s}"

                   % type_specific['gnat_stuff']['descriptive_type'])

        elif type_specific_kind == "TYPE_SPECIFIC_FLOATFORMAT":

            img = "floatformat[0..1] = %s" % type_specific['floatformat']

        elif type_specific_kind == "TYPE_SPECIFIC_CALLING_CONVENTION":

            img = ("calling_convention = %d"

                   % type_specific['calling_convention'])

        else:

            img = ("type_specific = ??? (unknown type_secific_kind: %s)"

                   % type_specific_kind)

        return img

    def to_string(self):

        """Return a pretty-printed image of our main_type.

        """

        fields = []

        fields.append("name = %s" % self.val['name'])

        fields.append("tag_name = %s" % self.val['tag_name'])

        fields.append("code = %s" % self.val['code'])

        fields.append("flags = [%s]" % self.flags_to_string())

        fields.append("owner = %s" % self.owner_to_string())

        fields.append("target_type = %s" % self.val['target_type'])

        fields.append("vptr_basetype = %s" % self.val['vptr_basetype'])

        if self.val['nfields'] > 0:

            for fieldno in range(self.val['nfields']):

                fields.append(self.struct_field_img(fieldno))

        if self.val['code'] == gdb.TYPE_CODE_RANGE:

            fields.append(self.bounds_img())

        fields.append(self.type_specific_img())

        return "\n{" + ",\n ".join(fields) + "}"

def type_lookup_function(val):

    """A routine that returns the correct pretty printer for VAL

    if appropriate.  Returns None otherwise.

    """

    if val.type.tag == "type":

        return StructTypePrettyPrinter(val)

    elif val.type.tag == "main_type":

        return StructMainTypePrettyPrinter(val)

    return None

def register_pretty_printer(objfile):

    """A routine to register a pretty-printer against the given OBJFILE.

    """

    objfile.pretty_printers.append(type_lookup_function)

if __name__ == "__main__":

    if gdb.current_objfile() is not None:

        # This is the case where this script is being "auto-loaded"

        # for a given objfile.  Register the pretty-printer for that

        # objfile.

        register_pretty_printer(gdb.current_objfile())

    else:

        # We need to locate the objfile corresponding to the GDB

        # executable, and register the pretty-printer for that objfile.

        # FIXME: The condition used to match the objfile is too simplistic

        # and will not work on Windows.

        for objfile in gdb.objfiles():

            if os.path.basename(objfile.filename) == "gdb":

                objfile.pretty_printers.append(type_lookup_function)