GDB (xrefs)

/tmp/gdb-8.1/gdb/gdb-gdb.py
Go to the documentation of this file.
1 # Copyright (C) 2009-2018 Free Software Foundation, Inc.
2 #
3 # This file is part of GDB.
4 #
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 3 of the License, or
8 # (at your option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18 import gdb
19 import os.path
20
21 class TypeFlag:
22 """A class that allows us to store a flag name, its short name,
23 and its value.
24
25 In the GDB sources, struct type has a component called instance_flags
26 in which the value is the addition of various flags. These flags are
27 defined by the enumerates type_instance_flag_value. This class helps us
28 recreate a list with all these flags that is easy to manipulate and sort.
29 Because all flag names start with TYPE_INSTANCE_FLAG_, a short_name
30 attribute is provided that strips this prefix.
31
32 ATTRIBUTES
33 name: The enumeration name (eg: "TYPE_INSTANCE_FLAG_CONST").
34 value: The associated value.
35 short_name: The enumeration name, with the suffix stripped.
36 """
37 def __init__(self, name, value):
38 self.name = name
39 self.value = value
40 self.short_name = name.replace("TYPE_INSTANCE_FLAG_", '')
41 def __cmp__(self, other):
42 """Sort by value order."""
43 return self.value.__cmp__(other.value)
44
45 # A list of all existing TYPE_INSTANCE_FLAGS_* enumerations,
46 # stored as TypeFlags objects. Lazy-initialized.
47 TYPE_FLAGS = None
48
49 class TypeFlagsPrinter:
50 """A class that prints a decoded form of an instance_flags value.
51
52 This class uses a global named TYPE_FLAGS, which is a list of
53 all defined TypeFlag values. Using a global allows us to compute
54 this list only once.
55
56 This class relies on a couple of enumeration types being defined.
57 If not, then printing of the instance_flag is going to be degraded,
58 but it's not a fatal error.
59 """
60 def __init__(self, val):
61 self.val = val
62 def __str__(self):
63 global TYPE_FLAGS
64 if TYPE_FLAGS is None:
65 self.init_TYPE_FLAGS()
66 if not self.val:
67 return "0"
68 if TYPE_FLAGS:
69 flag_list = [flag.short_name for flag in TYPE_FLAGS
70 if self.val & flag.value]
71 else:
72 flag_list = ["???"]
73 return "0x%x [%s]" % (self.val, "|".join(flag_list))
74 def init_TYPE_FLAGS(self):
75 """Initialize the TYPE_FLAGS global as a list of TypeFlag objects.
76 This operation requires the search of a couple of enumeration types.
77 If not found, a warning is printed on stdout, and TYPE_FLAGS is
78 set to the empty list.
79
80 The resulting list is sorted by increasing value, to facilitate
81 printing of the list of flags used in an instance_flags value.
82 """
83 global TYPE_FLAGS
84 TYPE_FLAGS = []
85 try:
86 iflags = gdb.lookup_type("enum type_instance_flag_value")
87 except:
88 print("Warning: Cannot find enum type_instance_flag_value type.")
89 print(" `struct type' pretty-printer will be degraded")
90 return
91 TYPE_FLAGS = [TypeFlag(field.name, field.enumval)
92 for field in iflags.fields()]
93 TYPE_FLAGS.sort()
94
95 class StructTypePrettyPrinter:
96 """Pretty-print an object of type struct type"""
97 def __init__(self, val):
98 self.val = val
99 def to_string(self):
100 fields = []
101 fields.append("pointer_type = %s" % self.val['pointer_type'])
102 fields.append("reference_type = %s" % self.val['reference_type'])
103 fields.append("chain = %s" % self.val['reference_type'])
104 fields.append("instance_flags = %s"
105 % TypeFlagsPrinter(self.val['instance_flags']))
106 fields.append("length = %d" % self.val['length'])
107 fields.append("main_type = %s" % self.val['main_type'])
108 return "\n{" + ",\n ".join(fields) + "}"
109
110 class StructMainTypePrettyPrinter:
111 """Pretty-print an objet of type main_type"""
112 def __init__(self, val):
113 self.val = val
114 def flags_to_string(self):
115 """struct main_type contains a series of components that
116 are one-bit ints whose name start with "flag_". For instance:
117 flag_unsigned, flag_stub, etc. In essence, these components are
118 really boolean flags, and this method prints a short synthetic
119 version of the value of all these flags. For instance, if
120 flag_unsigned and flag_static are the only components set to 1,
121 this function will return "unsigned|static".
122 """
123 fields = [field.name.replace("flag_", "")
124 for field in self.val.type.fields()
125 if field.name.startswith("flag_")
126 and self.val[field.name]]
127 return "|".join(fields)
128 def owner_to_string(self):
129 """Return an image of component "owner".
130 """
131 if self.val['flag_objfile_owned'] != 0:
132 return "%s (objfile)" % self.val['owner']['objfile']
133 else:
134 return "%s (gdbarch)" % self.val['owner']['gdbarch']
135 def struct_field_location_img(self, field_val):
136 """Return an image of the loc component inside the given field
137 gdb.Value.
138 """
139 loc_val = field_val['loc']
140 loc_kind = str(field_val['loc_kind'])
141 if loc_kind == "FIELD_LOC_KIND_BITPOS":
142 return 'bitpos = %d' % loc_val['bitpos']
143 elif loc_kind == "FIELD_LOC_KIND_ENUMVAL":
144 return 'enumval = %d' % loc_val['enumval']
145 elif loc_kind == "FIELD_LOC_KIND_PHYSADDR":
146 return 'physaddr = 0x%x' % loc_val['physaddr']
147 elif loc_kind == "FIELD_LOC_KIND_PHYSNAME":
148 return 'physname = %s' % loc_val['physname']
149 elif loc_kind == "FIELD_LOC_KIND_DWARF_BLOCK":
150 return 'dwarf_block = %s' % loc_val['dwarf_block']
151 else:
152 return 'loc = ??? (unsupported loc_kind value)'
153 def struct_field_img(self, fieldno):
154 """Return an image of the main_type field number FIELDNO.
155 """
156 f = self.val['flds_bnds']['fields'][fieldno]
157 label = "flds_bnds.fields[%d]:" % fieldno
158 if f['artificial']:
159 label += " (artificial)"
160 fields = []
161 fields.append("name = %s" % f['name'])
162 fields.append("type = %s" % f['type'])
163 fields.append("loc_kind = %s" % f['loc_kind'])
164 fields.append("bitsize = %d" % f['bitsize'])
165 fields.append(self.struct_field_location_img(f))
166 return label + "\n" + " {" + ",\n ".join(fields) + "}"
167 def bounds_img(self):
168 """Return an image of the main_type bounds.
169 """
170 b = self.val['flds_bnds']['bounds'].dereference()
171 low = str(b['low'])
172 if b['low_undefined'] != 0:
173 low += " (undefined)"
174 high = str(b['high'])
175 if b['high_undefined'] != 0:
176 high += " (undefined)"
177 return "flds_bnds.bounds = {%s, %s}" % (low, high)
178 def type_specific_img(self):
179 """Return a string image of the main_type type_specific union.
180 Only the relevant component of that union is printed (based on
181 the value of the type_specific_kind field.
182 """
183 type_specific_kind = str(self.val['type_specific_field'])
184 type_specific = self.val['type_specific']
185 if type_specific_kind == "TYPE_SPECIFIC_NONE":
186 img = 'type_specific_field = %s' % type_specific_kind
187 elif type_specific_kind == "TYPE_SPECIFIC_CPLUS_STUFF":
188 img = "cplus_stuff = %s" % type_specific['cplus_stuff']
189 elif type_specific_kind == "TYPE_SPECIFIC_GNAT_STUFF":
190 img = ("gnat_stuff = {descriptive_type = %s}"
191 % type_specific['gnat_stuff']['descriptive_type'])
192 elif type_specific_kind == "TYPE_SPECIFIC_FLOATFORMAT":
193 img = "floatformat[0..1] = %s" % type_specific['floatformat']
194 elif type_specific_kind == "TYPE_SPECIFIC_FUNC":
195 img = ("calling_convention = %d"
196 % type_specific['func_stuff']['calling_convention'])
197 # tail_call_list is not printed.
198 elif type_specific_kind == "TYPE_SPECIFIC_SELF_TYPE":
199 img = "self_type = %s" % type_specific['self_type']
200 else:
201 img = ("type_specific = ??? (unknown type_secific_kind: %s)"
202 % type_specific_kind)
203 return img
204
205 def to_string(self):
206 """Return a pretty-printed image of our main_type.
207 """
208 fields = []
209 fields.append("name = %s" % self.val['name'])
210 fields.append("tag_name = %s" % self.val['tag_name'])
211 fields.append("code = %s" % self.val['code'])
212 fields.append("flags = [%s]" % self.flags_to_string())
213 fields.append("owner = %s" % self.owner_to_string())
214 fields.append("target_type = %s" % self.val['target_type'])
215 if self.val['nfields'] > 0:
216 for fieldno in range(self.val['nfields']):
217 fields.append(self.struct_field_img(fieldno))
218 if self.val['code'] == gdb.TYPE_CODE_RANGE:
219 fields.append(self.bounds_img())
220 fields.append(self.type_specific_img())
221
222 return "\n{" + ",\n ".join(fields) + "}"
223
224 def type_lookup_function(val):
225 """A routine that returns the correct pretty printer for VAL
226 if appropriate. Returns None otherwise.
227 """
228 if val.type.tag == "type":
229 return StructTypePrettyPrinter(val)
230 elif val.type.tag == "main_type":
231 return StructMainTypePrettyPrinter(val)
232 return None
233
234 def register_pretty_printer(objfile):
235 """A routine to register a pretty-printer against the given OBJFILE.
236 """
237 objfile.pretty_printers.append(type_lookup_function)
238
239 if __name__ == "__main__":
240 if gdb.current_objfile() is not None:
241 # This is the case where this script is being "auto-loaded"
242 # for a given objfile. Register the pretty-printer for that
243 # objfile.
244 register_pretty_printer(gdb.current_objfile())
245 else:
246 # We need to locate the objfile corresponding to the GDB
247 # executable, and register the pretty-printer for that objfile.
248 # FIXME: The condition used to match the objfile is too simplistic
249 # and will not work on Windows.
250 for objfile in gdb.objfiles():
251 if os.path.basename(objfile.filename) == "gdb":
252 objfile.pretty_printers.append(type_lookup_function)
gdb-gdb.StructMainTypePrettyPrinter.flags_to_string
def flags_to_string(self)
Definition: gdb-gdb.py:114
gdb-gdb.StructTypePrettyPrinter.to_string
def to_string(self)
Definition: gdb-gdb.py:99
gdb-gdb.TypeFlagsPrinter.init_TYPE_FLAGS
def init_TYPE_FLAGS(self)
Definition: gdb-gdb.py:74
gdb-gdb.TypeFlag.value
value
Definition: gdb-gdb.py:39
gdb-gdb.StructMainTypePrettyPrinter.owner_to_string
def owner_to_string(self)
Definition: gdb-gdb.py:128
gdb-gdb.TypeFlagsPrinter.val
val
Definition: gdb-gdb.py:61
gdb-gdb.StructMainTypePrettyPrinter.bounds_img
def bounds_img(self)
Definition: gdb-gdb.py:167
gdb-gdb.StructMainTypePrettyPrinter.val
val
Definition: gdb-gdb.py:113
gdb-gdb.TypeFlag.short_name
short_name
Definition: gdb-gdb.py:40
gdb-gdb.StructMainTypePrettyPrinter.__init__
def __init__(self, val)
Definition: gdb-gdb.py:112
gdb-gdb.TypeFlagsPrinter
Definition: gdb-gdb.py:49
gdb-gdb.TypeFlag.name
name
Definition: gdb-gdb.py:38
gdb-gdb.StructMainTypePrettyPrinter.to_string
def to_string(self)
Definition: gdb-gdb.py:205
gdb-gdb.StructTypePrettyPrinter
Definition: gdb-gdb.py:95
gdb-gdb.StructMainTypePrettyPrinter.struct_field_img
def struct_field_img(self, fieldno)
Definition: gdb-gdb.py:153
gdb-gdb.TypeFlagsPrinter.__str__
def __str__(self)
Definition: gdb-gdb.py:62
range
Definition: value.c:62
gdb-gdb.StructMainTypePrettyPrinter
Definition: gdb-gdb.py:110
gdb-gdb.StructTypePrettyPrinter.__init__
def __init__(self, val)
Definition: gdb-gdb.py:97
gdb-gdb.StructMainTypePrettyPrinter.type_specific_img
def type_specific_img(self)
Definition: gdb-gdb.py:178
gdb-gdb.TypeFlag.__cmp__
def __cmp__(self, other)
Definition: gdb-gdb.py:41
gdb-gdb.TypeFlag
Definition: gdb-gdb.py:21
gdb-gdb.type_lookup_function
def type_lookup_function(val)
Definition: gdb-gdb.py:224
gdb-gdb.StructMainTypePrettyPrinter.struct_field_location_img
def struct_field_location_img(self, field_val)
Definition: gdb-gdb.py:135
gdb-gdb.register_pretty_printer
def register_pretty_printer(objfile)
Definition: gdb-gdb.py:234
gdb-gdb.TypeFlagsPrinter.__init__
def __init__(self, val)
Definition: gdb-gdb.py:60
gdb-gdb.StructTypePrettyPrinter.val
val
Definition: gdb-gdb.py:98
gdb-gdb.TypeFlag.__init__
def __init__(self, name, value)
Definition: gdb-gdb.py:37