22 """A class that allows us to store a flag name, its short name,
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 two enumerates: type_flag_value, and type_instance_flag_value.
28 This class helps us recreate a list with all these flags that is
29 easy to manipulate and sort. Because all flag names start with either
30 TYPE_FLAG_ or TYPE_INSTANCE_FLAG_, a short_name attribute is provided
31 that strips this prefix.
34 name: The enumeration name (eg: "TYPE_FLAG_UNSIGNED").
35 value: The associated value.
36 short_name: The enumeration name, with the suffix stripped.
43 self.
short_name = name.replace(
"TYPE_INSTANCE_FLAG_",
'')
45 """Sort by value order."""
46 return self.value.__cmp__(other.value)
53 """A class that prints a decoded form of an instance_flags value.
55 This class uses a global named TYPE_FLAGS, which is a list of
56 all defined TypeFlag values. Using a global allows us to compute
59 This class relies on a couple of enumeration types being defined.
60 If not, then printing of the instance_flag is going to be degraded,
61 but it's not a fatal error.
67 if TYPE_FLAGS
is None:
72 flag_list = [flag.short_name
for flag
in TYPE_FLAGS
73 if self.
val & flag.value]
76 return "0x%x [%s]" % (self.
val,
"|".join(flag_list))
78 """Initialize the TYPE_FLAGS global as a list of TypeFlag objects.
79 This operation requires the search of a couple of enumeration types.
80 If not found, a warning is printed on stdout, and TYPE_FLAGS is
81 set to the empty list.
83 The resulting list is sorted by increasing value, to facilitate
84 printing of the list of flags used in an instance_flags value.
89 flags = gdb.lookup_type(
"enum type_flag_value")
91 print "Warning: Cannot find enum type_flag_value type."
92 print " `struct type' pretty-printer will be degraded"
95 iflags = gdb.lookup_type(
"enum type_instance_flag_value")
97 print "Warning: Cannot find enum type_instance_flag_value type."
98 print " `struct type' pretty-printer will be degraded"
102 TYPE_FLAGS = [
TypeFlag(field.name, field.enumval)
103 for field
in flags.fields()
104 if field.name !=
'TYPE_FLAG_MIN']
105 TYPE_FLAGS += [
TypeFlag(field.name, field.enumval)
106 for field
in iflags.fields()]
110 """Pretty-print an object of type struct type"""
115 fields.append(
"pointer_type = %s" % self.
val[
'pointer_type'])
116 fields.append(
"reference_type = %s" % self.
val[
'reference_type'])
117 fields.append(
"chain = %s" % self.
val[
'reference_type'])
118 fields.append(
"instance_flags = %s"
120 fields.append(
"length = %d" % self.
val[
'length'])
121 fields.append(
"main_type = %s" % self.
val[
'main_type'])
122 return "\n{" +
",\n ".join(fields) +
"}"
125 """Pretty-print an objet of type main_type"""
129 """struct main_type contains a series of components that
130 are one-bit ints whose name start with "flag_". For instance:
131 flag_unsigned, flag_stub, etc. In essence, these components are
132 really boolean flags, and this method prints a short synthetic
133 version of the value of all these flags. For instance, if
134 flag_unsigned and flag_static are the only components set to 1,
135 this function will return "unsigned|static".
137 fields = [field.name.replace(
"flag_",
"")
138 for field
in self.val.type.fields()
139 if field.name.startswith(
"flag_")
140 and self.
val[field.name]]
141 return "|".join(fields)
143 """Return an image of component "owner".
145 if self.
val[
'flag_objfile_owned'] != 0:
146 return "%s (objfile)" % self.
val[
'owner'][
'objfile']
148 return "%s (gdbarch)" % self.
val[
'owner'][
'gdbarch']
150 """Return an image of the loc component inside the given field
153 loc_val = field_val[
'loc']
154 loc_kind = str(field_val[
'loc_kind'])
155 if loc_kind ==
"FIELD_LOC_KIND_BITPOS":
156 return 'bitpos = %d' % loc_val[
'bitpos']
157 elif loc_kind ==
"FIELD_LOC_KIND_ENUMVAL":
158 return 'enumval = %d' % loc_val[
'enumval']
159 elif loc_kind ==
"FIELD_LOC_KIND_PHYSADDR":
160 return 'physaddr = 0x%x' % loc_val[
'physaddr']
161 elif loc_kind ==
"FIELD_LOC_KIND_PHYSNAME":
162 return 'physname = %s' % loc_val[
'physname']
163 elif loc_kind ==
"FIELD_LOC_KIND_DWARF_BLOCK":
164 return 'dwarf_block = %s' % loc_val[
'dwarf_block']
166 return 'loc = ??? (unsupported loc_kind value)'
168 """Return an image of the main_type field number FIELDNO.
170 f = self.
val[
'flds_bnds'][
'fields'][fieldno]
171 label =
"flds_bnds.fields[%d]:" % fieldno
173 label +=
" (artificial)"
175 fields.append(
"name = %s" % f[
'name'])
176 fields.append(
"type = %s" % f[
'type'])
177 fields.append(
"loc_kind = %s" % f[
'loc_kind'])
178 fields.append(
"bitsize = %d" % f[
'bitsize'])
180 return label +
"\n" +
" {" +
",\n ".join(fields) +
"}"
182 """Return an image of the main_type bounds.
184 b = self.
val[
'flds_bnds'][
'bounds'].dereference()
186 if b[
'low_undefined'] != 0:
187 low +=
" (undefined)"
188 high = str(b[
'high'])
189 if b[
'high_undefined'] != 0:
190 high +=
" (undefined)"
191 return "flds_bnds.bounds = {%s, %s}" % (low, high)
193 """Return a string image of the main_type type_specific union.
194 Only the relevant component of that union is printed (based on
195 the value of the type_specific_kind field.
197 type_specific_kind = str(self.
val[
'type_specific_field'])
198 type_specific = self.
val[
'type_specific']
199 if type_specific_kind ==
"TYPE_SPECIFIC_NONE":
200 img =
'type_specific_field = %s' % type_specific_kind
201 elif type_specific_kind ==
"TYPE_SPECIFIC_CPLUS_STUFF":
202 img =
"cplus_stuff = %s" % type_specific[
'cplus_stuff']
203 elif type_specific_kind ==
"TYPE_SPECIFIC_GNAT_STUFF":
204 img = (
"gnat_stuff = {descriptive_type = %s}"
205 % type_specific[
'gnat_stuff'][
'descriptive_type'])
206 elif type_specific_kind ==
"TYPE_SPECIFIC_FLOATFORMAT":
207 img =
"floatformat[0..1] = %s" % type_specific[
'floatformat']
208 elif type_specific_kind ==
"TYPE_SPECIFIC_FUNC":
209 img = (
"calling_convention = %d"
210 % type_specific[
'func_stuff'][
'calling_convention'])
212 elif type_specific_kind ==
"TYPE_SPECIFIC_SELF_TYPE":
213 img =
"self_type = %s" % type_specific[
'self_type']
215 img = (
"type_specific = ??? (unknown type_secific_kind: %s)"
216 % type_specific_kind)
220 """Return a pretty-printed image of our main_type.
223 fields.append(
"name = %s" % self.
val[
'name'])
224 fields.append(
"tag_name = %s" % self.
val[
'tag_name'])
225 fields.append(
"code = %s" % self.
val[
'code'])
228 fields.append(
"target_type = %s" % self.
val[
'target_type'])
229 if self.
val[
'nfields'] > 0:
230 for fieldno
in range(self.
val[
'nfields']):
232 if self.
val[
'code'] == gdb.TYPE_CODE_RANGE:
236 return "\n{" +
",\n ".join(fields) +
"}"
239 """A routine that returns the correct pretty printer for VAL
240 if appropriate. Returns None otherwise.
242 if val.type.tag ==
"type":
244 elif val.type.tag ==
"main_type":
249 """A routine to register a pretty-printer against the given OBJFILE.
251 objfile.pretty_printers.append(type_lookup_function)
253 if __name__ ==
"__main__":
254 if gdb.current_objfile()
is not None:
264 for objfile
in gdb.objfiles():
265 if os.path.basename(objfile.filename) ==
"gdb":
266 objfile.pretty_printers.append(type_lookup_function)
def flags_to_string(self)
def init_TYPE_FLAGS(self)
def owner_to_string(self)
def struct_field_img(self, fieldno)
def type_specific_img(self)
def type_lookup_function(val)
def struct_field_location_img(self, field_val)
def register_pretty_printer(objfile)
def __init__(self, name, value)