aboutsummaryrefslogtreecommitdiffstats
path: root/share/qtcreator
diff options
context:
space:
mode:
Diffstat (limited to 'share/qtcreator')
-rw-r--r--share/qtcreator/debugger/cdbbridge.py161
-rw-r--r--share/qtcreator/debugger/dumper.py2816
-rw-r--r--share/qtcreator/debugger/gdbbridge.py656
-rw-r--r--share/qtcreator/debugger/lldbbridge.py606
-rw-r--r--share/qtcreator/debugger/qttypes.py68
5 files changed, 2208 insertions, 2099 deletions
diff --git a/share/qtcreator/debugger/cdbbridge.py b/share/qtcreator/debugger/cdbbridge.py
index b5fc683cba..4ac053eb55 100644
--- a/share/qtcreator/debugger/cdbbridge.py
+++ b/share/qtcreator/debugger/cdbbridge.py
@@ -75,6 +75,13 @@ class Dumper(DumperBase):
self.outputLock = threading.Lock()
self.isCdb = True
+ #FIXME
+ typeid = self.typeid_for_string('@QVariantMap')
+ del self.type_code_cache[typeid]
+ del self.type_target_cache[typeid]
+ del self.type_size_cache[typeid]
+ del self.type_alignment_cache[typeid]
+
def enumValue(self, nativeValue):
val = nativeValue.nativeDebuggerValue()
# remove '0n' decimal prefix of the native cdb value output
@@ -117,6 +124,7 @@ class Dumper(DumperBase):
elif not nativeValue.type().resolved and nativeValue.type().code() == TypeCode.Struct and not nativeValue.hasChildren():
val.ldisplay = self.enumValue(nativeValue)
val.isBaseClass = val.name == nativeValue.type().name()
+ val.typeid = self.from_native_type(nativeValue.type())
val.nativeValue = nativeValue
val.laddress = nativeValue.address()
val.lbitsize = nativeValue.bitsize()
@@ -137,14 +145,10 @@ class Dumper(DumperBase):
for f in nativeType.fields()])
return typeId
- def nativeValueType(self, nativeValue):
- return self.fromNativeType(nativeValue.type())
-
- def fromNativeType(self, nativeType):
+ def from_native_type(self, nativeType):
self.check(isinstance(nativeType, cdbext.Type))
- typeId = self.nativeTypeId(nativeType)
- if self.typeData.get(typeId, None) is not None:
- return self.Type(self, typeId)
+ typeid = self.typeid_for_string(self.nativeTypeId(nativeType))
+ self.type_nativetype_cache[typeid] = nativeType
if nativeType.name().startswith('void'):
nativeType = FakeVoidType(nativeType.name(), self)
@@ -154,70 +158,61 @@ class Dumper(DumperBase):
if nativeType.name().startswith('<function>'):
code = TypeCode.Function
elif nativeType.targetName() != nativeType.name():
- return self.createPointerType(nativeType.targetName())
+ return self.create_pointer_typeid(self.typeid_for_string(nativeType.targetName()))
if code == TypeCode.Array:
# cdb reports virtual function tables as arrays those ar handled separetly by
# the DumperBase. Declare those types as structs prevents a lookup to a
# none existing type
if not nativeType.name().startswith('__fptr()') and not nativeType.name().startswith('<gentype '):
- targetName = nativeType.targetName()
- count = nativeType.arrayElements()
- if targetName.endswith(']'):
- (prefix, suffix, inner_count) = self.splitArrayType(targetName)
- type_name = '%s[%d][%d]%s' % (prefix, count, inner_count, suffix)
- else:
- type_name = '%s[%d]' % (targetName, count)
- tdata = self.TypeData(self, typeId)
- tdata.name = type_name
- tdata.code = TypeCode.Array
- tdata.ltarget = targetName
- tdata.lbitsize = lambda: nativeType.bitsize()
- return self.Type(self, typeId)
+ targetName = nativeType.targetName().strip()
+ self.type_name_cache[typeid] = nativeType.name()
+ self.type_code_cache[typeid] = code
+ self.type_target_cache[typeid] = self.typeid_for_string(targetName)
+ self.type_size_cache[typeid] = nativeType.bitsize() // 8
+ return typeid
code = TypeCode.Struct
- tdata = self.TypeData(self, typeId)
- tdata.name = nativeType.name()
- tdata.lbitsize = lambda: nativeType.bitsize()
- tdata.code = code
- tdata.moduleName = lambda: nativeType.module()
- if code == TypeCode.Struct:
- tdata.lfields = lambda value: \
- self.listFields(nativeType, value)
- tdata.lalignment = lambda: \
- self.nativeStructAlignment(nativeType)
- tdata.enumDisplay = lambda intval, addr, form: \
+ self.type_name_cache[typeid] = nativeType.name()
+ self.type_size_cache[typeid] = nativeType.bitsize() // 8
+ self.type_code_cache[typeid] = code
+ self.type_modulename_cache[typeid] = nativeType.module()
+ self.type_enum_display_cache[typeid] = lambda intval, addr, form: \
self.nativeTypeEnumDisplay(nativeType, intval, form)
- tdata.templateArguments = lambda: \
- self.listTemplateParameters(nativeType.name())
- return self.Type(self, typeId)
+ return typeid
- def listNativeValueChildren(self, nativeValue):
+ def listNativeValueChildren(self, nativeValue, include_bases):
+ fields = []
index = 0
nativeMember = nativeValue.childFromIndex(index)
while nativeMember:
+ # Why this restriction to things with address? Can't nativeValue
+ # be e.g. located in registers, without address?
if nativeMember.address() != 0:
- yield self.fromNativeValue(nativeMember)
+ if include_bases or nativeMember.name() != nativeMember.type().name():
+ field = self.fromNativeValue(nativeMember)
+ fields.append(field)
index += 1
nativeMember = nativeValue.childFromIndex(index)
+ return fields
- def listValueChildren(self, value):
+ def listValueChildren(self, value, include_bases=True):
nativeValue = value.nativeValue
if nativeValue is None:
nativeValue = cdbext.createValue(value.address(), self.lookupNativeType(value.type.name, 0))
- return self.listNativeValueChildren(nativeValue)
+ return self.listNativeValueChildren(nativeValue, include_bases)
- def listFields(self, nativeType, value):
+ def nativeListMembers(self, value, native_type, include_bases):
nativeValue = value.nativeValue
if nativeValue is None:
- nativeValue = cdbext.createValue(value.address(), nativeType)
- return self.listNativeValueChildren(nativeValue)
+ nativeValue = cdbext.createValue(value.address(), native_type)
+ return self.listNativeValueChildren(nativeValue, include_bases)
def nativeStructAlignment(self, nativeType):
#DumperBase.warn("NATIVE ALIGN FOR %s" % nativeType.name)
def handleItem(nativeFieldType, align):
- a = self.fromNativeType(nativeFieldType).alignment()
+ a = self.type_alignment(self.from_native_type(nativeFieldType))
return a if a > align else align
align = 1
for f in nativeType.fields():
@@ -398,20 +393,6 @@ class Dumper(DumperBase):
else:
return typeName
- def lookupType(self, typeNameIn, module=0):
- if len(typeNameIn) == 0:
- return None
- typeName = self.stripQintTypedefs(typeNameIn)
- if self.typeData.get(typeName, None) is None:
- nativeType = self.lookupNativeType(typeName, module)
- if nativeType is None:
- return None
- _type = self.fromNativeType(nativeType)
- if _type.typeId != typeName:
- self.registerTypeAlias(_type.typeId, typeName)
- return _type
- return self.Type(self, typeName)
-
def lookupNativeType(self, name, module=0):
if name.startswith('void'):
return FakeVoidType(name, self)
@@ -439,9 +420,6 @@ class Dumper(DumperBase):
ptr = cdbext.getAddressByName(type.name + '::staticMetaObject')
return ptr
- def warn(self, msg):
- self.put('{name="%s",value="",type="",numchild="0"},' % msg)
-
def fetchVariables(self, args):
self.resetStats()
(ok, res) = self.tryFetchInterpreterVariables(args)
@@ -458,13 +436,17 @@ class Dumper(DumperBase):
self.anonNumber = 0
variables = []
- for val in cdbext.listOfLocals(self.partialVariable):
- dumperVal = self.fromNativeValue(val)
- dumperVal.lIsInScope = dumperVal.name not in self.uninitialized
- variables.append(dumperVal)
+ try:
+ for val in cdbext.listOfLocals(self.partialVariable):
+ dumperVal = self.fromNativeValue(val)
+ dumperVal.lIsInScope = dumperVal.name not in self.uninitialized
+ variables.append(dumperVal)
- self.handleLocals(variables)
- self.handleWatches(args)
+ self.handleLocals(variables)
+ self.handleWatches(args)
+ except Exception:
+ t,v,tb = sys.exc_info()
+ self.showException("FETCH VARIABLES", t, v, tb)
self.put('],partial="%d"' % (len(self.partialVariable) > 0))
self.put(',timings=%s' % self.timings)
@@ -485,9 +467,6 @@ class Dumper(DumperBase):
def findValueByExpression(self, exp):
return cdbext.parseAndEvaluate(exp)
- def nativeDynamicTypeName(self, address, baseType):
- return None # Does not work with cdb
-
def nativeValueDereferenceReference(self, value):
return self.nativeValueDereferencePointer(value)
@@ -518,7 +497,7 @@ class Dumper(DumperBase):
else:
val = self.Value(self)
val.laddress = value.pointer()
- val._type = DumperBase.Type(self, value.type.targetName)
+ val.typeid = self.typeid_for_string(value.type.targetName)
val.nativeValue = value.nativeValue
return val
@@ -540,14 +519,11 @@ class Dumper(DumperBase):
res = self.nativeParseAndEvaluate(symbolName)
return None if res is None else res.address()
- def putItemX(self, value):
- #DumperBase.warn('PUT ITEM: %s' % value.stringify())
+ def putItem(self, value: DumperBase.Value):
typeobj = value.type # unqualified()
typeName = typeobj.name
- self.addToCache(typeobj) # Fill type cache
-
if not value.lIsInScope:
self.putSpecialValue('optimizedout')
#self.putType(typeobj)
@@ -571,8 +547,7 @@ class Dumper(DumperBase):
return
self.putAddress(value.address())
- if value.lbitsize is not None:
- self.putField('size', value.lbitsize // 8)
+ self.putField('size', self.type_size(value.typeid))
if typeobj.code == TypeCode.Function:
#DumperBase.warn('FUNCTION VALUE: %s' % value)
@@ -738,7 +713,7 @@ class Dumper(DumperBase):
#DumperBase.warn('INAME: %s' % self.currentIName)
if self.autoDerefPointers:
# Generic pointer type with AutomaticFormat, but never dereference char types:
- if value.type.targetName not in (
+ if value.type.targetName.strip() not in (
'char',
'signed char',
'int8_t',
@@ -769,7 +744,7 @@ class Dumper(DumperBase):
def putCStyleArray(self, value):
arrayType = value.type
- innerType = arrayType.ltarget
+ innerType = arrayType.target()
address = value.address()
if address:
self.putValue('@0x%x' % address, priority=-1)
@@ -783,7 +758,7 @@ class Dumper(DumperBase):
p = value.address()
if displayFormat != DisplayFormat.Raw and p:
- if innerType.name in (
+ if innerType.name.strip() in (
'char',
'int8_t',
'qint8',
@@ -828,7 +803,7 @@ class Dumper(DumperBase):
innerSize = innerType.size()
self.putNumChild(n)
#DumperBase.warn('ADDRESS: 0x%x INNERSIZE: %s INNERTYPE: %s' % (addrBase, innerSize, innerType))
- enc = innerType.simpleEncoding()
+ enc = self.type_encoding_cache.get(innerType.typeid, None)
maxNumChild = self.maxArrayCount()
if enc:
self.put('childtype="%s",' % innerType.name)
@@ -863,12 +838,8 @@ class Dumper(DumperBase):
if innerType in ('wchar_t', 'WCHAR'):
self.putType(typeName)
- charSize = self.lookupType('wchar_t').size()
- (length, data) = self.encodeCArray(ptr, charSize, limit)
- if charSize == 2:
- self.putValue(data, 'utf16', length=length)
- else:
- self.putValue(data, 'ucs4', length=length)
+ (length, data) = self.encodeCArray(ptr, 2, limit)
+ self.putValue(data, 'utf16', length=length)
return True
if displayFormat == DisplayFormat.Latin1String:
@@ -931,19 +902,12 @@ class Dumper(DumperBase):
self.putItem(derefValue)
self.currentChildType = savedCurrentChildType
- def extractPointer(self, value):
- code = 'I' if self.ptrSize() == 4 else 'Q'
- return self.extractSomething(value, code, 8 * self.ptrSize())
-
def createValue(self, datish, typish):
- if self.isInt(datish): # Used as address.
+ if isinstance(datish, int): # Used as address.
return self.createValueFromAddressAndType(datish, typish)
if isinstance(datish, bytes):
val = self.Value(self)
- if isinstance(typish, self.Type):
- val._type = typish
- else:
- val._type = self.Type(self, typish)
+ val.typeid = self.create_typeid(typish)
#DumperBase.warn('CREATING %s WITH DATA %s' % (val.type.name, self.hexencode(datish)))
val.ldata = datish
val.check()
@@ -952,11 +916,8 @@ class Dumper(DumperBase):
def createValueFromAddressAndType(self, address, typish):
val = self.Value(self)
- if isinstance(typish, self.Type):
- val._type = typish
- else:
- val._type = self.Type(self, typish)
+ val.typeid = self.create_typeid(typish)
val.laddress = address
if self.useDynamicType:
- val._type = val.type.dynamicType(address)
+ val.typeid = self.dynamic_typeid_at_address(val.typeid, address)
return val
diff --git a/share/qtcreator/debugger/dumper.py b/share/qtcreator/debugger/dumper.py
index 059bf7b23e..488f1e362e 100644
--- a/share/qtcreator/debugger/dumper.py
+++ b/share/qtcreator/debugger/dumper.py
@@ -3,7 +3,7 @@
import os
import codecs
-import collections
+import functools
import glob
import struct
import sys
@@ -31,11 +31,7 @@ except:
def hexencode_(s):
return ''.join(["%x" % c for c in s])
-if sys.version_info[0] >= 3:
- toInteger = int
-else:
- toInteger = long
-
+toInteger = int
class ReportItem():
"""
@@ -55,19 +51,6 @@ class ReportItem():
% (self.value, self.encoding, self.priority, self.length)
-class Timer():
- def __init__(self, d, desc):
- self.d = d
- self.desc = desc + '-' + d.currentIName
-
- def __enter__(self):
- self.starttime = time.time()
-
- def __exit__(self, exType, exValue, exTraceBack):
- elapsed = int(1000 * (time.time() - self.starttime))
- self.d.timings.append([self.desc, elapsed])
-
-
class Children():
def __init__(self, d, numChild=1, childType=None, childNumChild=None,
maxNumChild=None, addrBase=None, addrStep=None):
@@ -147,20 +130,28 @@ class UnnamedSubItem(SubItem):
class DumperBase():
@staticmethod
def warn(message):
- print('bridgemessage={msg="%s"},' % message.replace('"', '$').encode('latin1'))
+ print('bridgemessage={msg="%s"}' % message.replace('"', "'").replace('\\', '\\\\'))
- @staticmethod
- def showException(msg, exType, exValue, exTraceback):
- DumperBase.warn('**** CAUGHT EXCEPTION: %s ****' % msg)
+ #@staticmethod
+ def showException(self, msg, exType, exValue, exTraceback):
+ self.warn('**** CAUGHT EXCEPTION: %s ****' % msg)
try:
import traceback
- for line in traceback.format_exception(exType, exValue, exTraceback):
- DumperBase.warn('%s' % line)
+ for frame_desc in traceback.format_exception(exType, exValue, exTraceback):
+ for line in frame_desc.split('\n'):
+ self.warn(line)
except:
pass
- def timer(self, desc):
- return Timer(self, desc)
+ def dump_location(self):
+ import traceback
+ from io import StringIO
+ io = StringIO()
+ traceback.print_stack(file=io)
+ data = io.getvalue()
+ self.warn('LOCATION:')
+ for line in data.split('\n')[:-3]:
+ self.warn(line)
def __init__(self):
self.isCdb = False
@@ -185,7 +176,6 @@ class DumperBase():
self.passExceptions = False
self.isTesting = False
- self.typeData = {}
self.isBigEndian = False
self.packCode = '<'
@@ -197,6 +187,8 @@ class DumperBase():
self.dumpermodules = []
+ self.init_type_cache()
+
try:
# Fails in the piping case
self.dumpermodules = [
@@ -217,9 +209,10 @@ class DumperBase():
self.currentPrintsAddress = True
self.currentChildType = None
self.currentChildNumChild = None
- self.registerKnownTypes()
+ self.register_known_types()
def setVariableFetchingOptions(self, args):
+ self.last_args = args
self.resultVarName = args.get('resultvarname', '')
self.expandedINames = args.get('expanded', {})
self.stringCutOff = int(args.get('stringcutoff', 10000))
@@ -239,10 +232,25 @@ class DumperBase():
self.partialVariable = args.get('partialvar', '')
self.uninitialized = args.get('uninitialized', [])
self.uninitialized = list(map(lambda x: self.hexdecode(x), self.uninitialized))
- self.partialUpdate = int(args.get('partial', '0'))
- #DumperBase.warn('NAMESPACE: "%s"' % self.qtNamespace())
- #DumperBase.warn('EXPANDED INAMES: %s' % self.expandedINames)
- #DumperBase.warn('WATCHERS: %s' % self.watchers)
+ #self.warn('NAMESPACE: "%s"' % self.qtNamespace())
+ #self.warn('EXPANDED INAMES: %s' % self.expandedINames)
+ #self.warn('WATCHERS: %s' % self.watchers)
+
+ # Call this with 'py theDumper.profile1() from Creator
+ def profile(self):
+ '''Internal profiling'''
+ import cProfile
+ import visualize
+ profiler = cProfile.Profile()
+ profiler.enable()
+ self.profiled_command()
+ profiler.disable()
+ visualize.profile_visualize(profiler.getstats())
+
+ def profiled_command(self):
+ args = self.last_args
+ args['partialvar'] = ''
+ self.fetchVariables(args)
def setFallbackQtVersion(self, args):
version = int(args.get('version', self.fallbackQtVersion))
@@ -279,7 +287,6 @@ class DumperBase():
self.generalCache = {}
self.counts = {}
- self.structPatternCache = {}
self.timings = []
self.expandableINames = set({})
@@ -331,7 +338,7 @@ class DumperBase():
self.currentType = ReportItem()
def exitSubItem(self, item, exType, exValue, exTraceBack):
- #DumperBase.warn('CURRENT VALUE: %s: %s %s' %
+ #self.warn('CURRENT VALUE: %s: %s %s' %
# (self.currentIName, self.currentValue, self.currentType))
if exType is not None:
if self.passExceptions:
@@ -341,9 +348,9 @@ class DumperBase():
if not self.isCli:
try:
if self.currentType.value:
- typeName = self.currentType.value
- if len(typeName) > 0 and typeName != self.currentChildType:
- self.putField('type', typeName)
+ typename = self.currentType.value
+ if len(typename) > 0 and typename != self.currentChildType:
+ self.putField('type', typename)
if self.currentValue.value is None:
self.put('value="",encoding="notaccessible",numchild="0",')
else:
@@ -361,8 +368,8 @@ class DumperBase():
self.indent -= 1
try:
if self.currentType.value:
- typeName = self.currentType.value
- self.put('<%s> = {' % typeName)
+ typename = self.currentType.value
+ self.put('<%s> = {' % typename)
if self.currentValue.value is None:
self.put('<not accessible>')
@@ -388,14 +395,14 @@ class DumperBase():
self.currentType = item.savedType
return True
- def stripForFormat(self, typeName):
- if not isinstance(typeName, str):
- raise RuntimeError('Expected string in stripForFormat(), got %s' % type(typeName))
- if typeName in self.cachedFormats:
- return self.cachedFormats[typeName]
+ def stripForFormat(self, typename):
+ if not isinstance(typename, str):
+ raise RuntimeError('Expected string in stripForFormat(), got %s' % type(typename))
+ if typename in self.cachedFormats:
+ return self.cachedFormats[typename]
stripped = ''
inArray = 0
- for c in typeName:
+ for c in typename:
if c == '<':
break
if c == ' ':
@@ -407,59 +414,192 @@ class DumperBase():
if inArray and ord(c) >= 48 and ord(c) <= 57:
continue
stripped += c
- self.cachedFormats[typeName] = stripped
+ self.cachedFormats[typename] = stripped
return stripped
- def templateArgument(self, typeobj, position):
- return typeobj.templateArgument(position)
+ def templateArgument(self, typeobj, index):
+ return self.type_template_argument(typeobj.typeid, index)
def intType(self):
- result = self.lookupType('int')
- self.intType = lambda: result
- return result
+ return self.type_for_int
def charType(self):
- result = self.lookupType('char')
- self.charType = lambda: result
- return result
+ return self.type_for_char
def ptrSize(self):
result = self.lookupType('void*').size()
self.ptrSize = lambda: result
return result
- def lookupType(self, typeName):
- nativeType = self.lookupNativeType(typeName)
- return None if nativeType is None else self.fromNativeType(nativeType)
-
- def registerKnownTypes(self):
- tdata = self.TypeData(self, 'unsigned short')
- tdata.lbitsize = 16
- tdata.lalignment = 2
- tdata.code = TypeCode.Integral
+ def lookupType(self, typename):
+ if not isinstance(typename, str):
+ raise RuntimeError('ARG ERROR FOR lookupType, got %s' % type(typename))
+
+ typeid = self.typeid_for_string(typename)
+ native_type = self.type_nativetype_cache.get(typeid)
+ if native_type is None:
+ native_type = self.lookupNativeType(typename)
+ if native_type is None:
+ #sCANNOT DETERMINE SIZE FOR TYelf.dump_location()
+ self.dump_location()
+ self.warn("TYPEIDS: %s" % self.typeid_cache)
+ self.warn("COULD NOT FIND TYPE '%s'" % typename)
+ return None
- tdata = self.TypeData(self, 'QChar')
- tdata.lbitsize = 16
- tdata.lalignment = 2
- tdata.code = TypeCode.Struct
- tdata.lfields = [self.Field(dumper=self, name='ucs',
- type='unsigned short', bitsize=16, bitpos=0)]
- tdata.templateArguments = lambda: []
+ self.type_nativetype_cache[typeid] = native_type
+ typeid = self.from_native_type(native_type)
+ if typeid == 0:
+ return None
+ return self.Type(self, typeid)
+
+ def register_type(self, name, code, size, enc=None):
+ typeid = self.typeid_for_string(name)
+ self.type_code_cache[typeid] = code
+ self.type_size_cache[typeid] = size
+ self.type_alignment_cache[typeid] = size
+ if enc is not None:
+ self.type_encoding_cache[typeid] = enc
+ return typeid
+
+ def register_int(self, name, size, enc=None):
+ typeid = self.typeid_for_string(name)
+ self.type_code_cache[typeid] = TypeCode.Integral
+ self.type_size_cache[typeid] = size
+ self.type_alignment_cache[typeid] = size
+ if enc is not None:
+ self.type_encoding_cache[typeid] = enc
+ return typeid
+
+ def register_enum(self, name, size):
+ typeid = self.typeid_for_string(name)
+ self.type_code_cache[typeid] = TypeCode.Enum
+ self.type_size_cache[typeid] = size
+ self.type_alignment_cache[typeid] = size
+ return typeid
+
+ def register_typedef(self, name, target_typeid):
+ typeid = self.typeid_for_string(name)
+ self.type_code_cache[typeid] = TypeCode.Typedef
+ self.type_target_cache[typeid] = target_typeid
+ self.type_size_cache[typeid] = self.type_size_cache[target_typeid]
+ self.type_alignment_cache[typeid] = self.type_alignment_cache[target_typeid]
+ return typeid
+
+ def register_struct(self, name, p5=0, p6=0, s=0):
+ # p5 = n -> n * ptrsize for Qt 5
+ # p6 = n -> n * ptrsize for Qt 6
+ #if self.qtVersion() >= 0x060000: # FIXME: Qt 5, ptrSize()
+ size = 8 * p6 + s
+ typeid = self.typeid_for_string(name)
+ self.type_code_cache[typeid] = TypeCode.Struct
+ self.type_size_cache[typeid] = size
+ self.type_alignment_cache[typeid] = 8
+ return typeid
+
+ def register_known_types(self):
+ typeid = 0
+ self.typeid_cache[''] = typeid
+ self.type_code_cache[typeid] = TypeCode.Void
+ self.type_name_cache[typeid] = '<Error>'
+ self.type_size_cache[typeid] = 1
+
+ typeid_char = self.register_int('char', 1, 'uint:1')
+ self.type_for_char = self.Type(self, typeid_char)
+ self.register_int('signed char', 1, 'int:1')
+ self.register_int('unsigned char', 1, 'uint:1')
+ self.register_int('bool', 1, 'uint:1')
+ self.register_int('char8_t', 1, 'uint:1')
+ self.register_int('int8_t', 1, 'int:1')
+ self.register_int('uint8_t', 1, 'uint:1')
+ self.register_int('qint8', 1, 'int:1')
+ self.register_int('quint8', 1, 'uint:1')
+
+ self.register_int('short', 2, 'int:2')
+ self.register_int('short int', 2, 'int:2')
+ self.register_int('signed short', 2, 'int:2')
+ self.register_int('signed short int', 2, 'int:2')
+ typeid_unsigned_short = \
+ self.register_int('unsigned short', 2, 'uint:2')
+ self.register_int('unsigned short int', 2, 'uint:2')
+ self.register_int('char16_t', 2, 'uint:2')
+ self.register_int('int16_t', 2, 'int:2')
+ self.register_int('uint16_t', 2, 'uint:2')
+ self.register_int('qint16', 2, 'int:2')
+ self.register_int('quint16', 2, 'uint:2')
+
+ typeid_int = self.register_type('int', 4, 'int:4')
+ self.type_for_int = self.Type(self, typeid_int)
+ self.register_int('int', 4, 'int:4')
+ self.register_int('signed int', 4, 'int:4')
+ self.register_int('unsigned int', 4, 'uint:4')
+ self.register_int('char32_t', 4, 'int:4')
+ self.register_int('int32_t', 4, 'int:4')
+ self.register_int('uint32_t', 4, 'uint:4')
+ self.register_int('qint32', 4, 'int:4')
+ self.register_int('quint32', 4, 'uint:4')
+
+ self.register_int('long long', 8, 'int:8')
+ self.register_int('signed long long', 8, 'int:8')
+ self.register_int('unsigned long long', 8, 'uint:8')
+ self.register_int('int64_t', 8, 'int:8')
+ self.register_int('uint64_t', 8, 'uint:8')
+ self.register_int('qint64', 8, 'int:8')
+ self.register_int('quint64', 8, 'uint:8')
+
+ self.register_type('float', TypeCode.Float, 4, 'float:4')
+ typeid_double = self.register_type('double', TypeCode.Float, 8, 'float:8')
+ self.register_typedef('qreal', typeid_double)
+
+ typeid_qchar = self.register_type('@QChar', TypeCode.Struct, 2, 'uint:2')
+ #self.type_fields_cache[typeid_qchar] = [
+ # self.Field(name='ucs', typeid=typeid_unsigned_short, bitsize=16, bitpos=0)]
+
+ self.register_enum('@Qt::ItemDataRole', 4)
+
+ self.register_struct('@QObject', p5=2, p6=2)
+ self.register_struct('@QObjectPrivate', p5=10, p6=10) # FIXME: Not exact
+
+ self.register_struct('@QByteArray', p5=1, p6=3)
+ self.register_struct('@QString', p5=1, p6=3)
+ self.register_struct('@QStandardItemData', p5=3, p6=5)
+ self.register_struct('@QVariant', p5=2, p6=4)
+ self.register_struct('@QXmlAttributes::Attribute', p5=4, p6=12)
+
+ self.register_struct('@QList<@QObject*>', p5=1, p6=3)
+ self.register_struct('@QList<@QStandardItemData>', p5=1, p6=3)
+ self.register_struct('@QList<@QRect>', p5=1, p6=3)
+
+ typeid_var_list = self.register_struct('@QList<@QVariant>', p5=1, p6=3)
+ self.register_typedef('@QVariantList', typeid_var_list)
+
+ typeid_var_map = self.register_struct('@QMap<@QString, @QVariant>', p5=1, p6=1)
+ self.register_typedef('@QVariantMap', typeid_var_map)
+
+ typeid_var_hash = self.register_struct('@QHash<@QString, @QVariant>', p5=1, p6=1)
+ self.register_typedef('@QVariantHash', typeid_var_hash)
+
+ self.register_struct('@QPoint', s=8)
+ self.register_struct('@QPointF', s=16)
+ self.register_struct('@QLine', s=16)
+ self.register_struct('@QLineF', s=32)
+
+ # FIXME: Comment out for production, see [MARK_A]
+ name1 = 'std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>'
+ self.register_struct(name1, p6=4)
def nativeDynamicType(self, address, baseType):
return baseType # Override in backends.
- def listTemplateParameters(self, typename):
- return self.listTemplateParametersManually(typename)
-
- def listTemplateParametersManually(self, typename):
+ def fill_template_parameters_manually(self, typeid):
+ typename = self.type_name(typeid)
# Undo id mangling for template typedefs. Relevant for QPair.
if typename.endswith('}'):
typename = typename[typename.find('{') + 1 : -1]
- targs = []
if not typename.endswith('>'):
- return targs
+ return
+
+ targs = []
def push(inner):
# Handle local struct definitions like QList<main(int, char**)::SomeStruct>
@@ -471,14 +611,14 @@ class DumperBase():
inner = inner[6:].strip()
if inner.endswith(' const'):
inner = inner[:-6].strip()
- #DumperBase.warn("FOUND: %s" % inner)
+ #self.warn("FOUND: %s" % inner)
targs.append(inner)
- #DumperBase.warn("SPLITTING %s" % typename)
+ #self.warn("SPLITTING %s" % typename)
level = 0
inner = ''
for c in typename[::-1]: # Reversed...
- #DumperBase.warn("C: %s" % c)
+ #self.warn("C: %s" % c)
if c == '>':
if level > 0:
inner += c
@@ -492,7 +632,7 @@ class DumperBase():
inner = ''
break
elif c == ',':
- #DumperBase.warn('c: %s level: %s' % (c, level))
+ #self.warn('c: %s level: %s' % (c, level))
if level == 1:
push(inner)
inner = ''
@@ -501,28 +641,34 @@ class DumperBase():
else:
inner += c
- #DumperBase.warn("TARGS: %s %s" % (typename, targs))
- res = []
+ #self.warn("TARGS: %s %s" % (typename, targs))
+ idx = 0
for item in targs[::-1]:
if len(item) == 0:
continue
- c = ord(item[0])
- if c in (45, 46) or (c >= 48 and c < 58): # '-', '.' or digit.
- if item.find('.') > -1:
- res.append(float(item))
- else:
- if item.endswith('l'):
- item = item[:-1]
- if item.endswith('u'):
- item = item[:-1]
- val = toInteger(item)
- if val > 0x80000000:
- val -= 0x100000000
- res.append(val)
+ if item == "false": # Triggered in StdTuple dumper
+ self.type_template_arguments_cache[(typeid, idx)] = False
+ elif item == "true":
+ self.type_template_arguments_cache[(typeid, idx)] = True
else:
- res.append(self.Type(self, item))
- #DumperBase.warn("RES: %s %s" % (typename, [(None if t is None else t.name) for t in res]))
- return res
+ c = ord(item[0])
+ if c in (45, 46) or (c >= 48 and c < 58): # '-', '.' or digit.
+ if '.' in item:
+ res.append(float(item))
+ else:
+ if item.endswith('l'):
+ item = item[:-1]
+ if item.endswith('u'):
+ item = item[:-1]
+ val = int(item)
+ if val > 0x80000000:
+ val -= 0x100000000
+ self.type_template_arguments_cache[(typeid, idx)] = val
+ else:
+ targ = self.Type(self, self.create_typeid_from_name(item))
+ self.type_template_arguments_cache[(typeid, idx)] = targ
+ idx += 1
+ #self.warn('MANUAL: %s %s' % (type_name, targs))
# Hex decoding operating on str, return str.
@staticmethod
@@ -619,7 +765,7 @@ class DumperBase():
(dummy, dummy, dummy, length) = self.split('IIIp', array_data_ptr)
length = self.extractInt(array_data_ptr + 3 * self.ptrSize()) & 0x3ffffff
alloc = length # pretend.
- data = self.extractPointer(array_data_ptr + self.ptrSize())
+ data = self.extract_pointer_at_address(array_data_ptr + self.ptrSize())
return data, length, alloc
def encodeStringHelper(self, value, limit):
@@ -666,14 +812,14 @@ class DumperBase():
displayFormat=DisplayFormat.Automatic,
makeExpandable=True):
charSize = charType.size()
- self.putCharArrayValue(data, size, charSize, displayFormat=displayFormat)
+ self.putCharArrayValue(data, size, charSize, displayFormat)
if makeExpandable:
self.putNumChild(size)
if self.isExpanded():
with Children(self):
for i in range(size):
- self.putSubItem(size, self.createValue(data + i * charSize, charType))
+ self.putSubItem(size, self.createValueFromAddress(data + i * charSize, charType))
def readMemory(self, addr, size):
return self.hexencode(bytes(self.readRawMemory(addr, size)))
@@ -699,39 +845,6 @@ class DumperBase():
def stringData(self, value): # -> (data, size, alloc)
return self.qArrayData(value)
- def extractTemplateArgument(self, typename, position):
- level = 0
- skipSpace = False
- inner = ''
- for c in typename[typename.find('<') + 1: -1]:
- if c == '<':
- inner += c
- level += 1
- elif c == '>':
- level -= 1
- inner += c
- elif c == ',':
- if level == 0:
- if position == 0:
- return inner.strip()
- position -= 1
- inner = ''
- else:
- inner += c
- skipSpace = True
- else:
- if skipSpace and c == ' ':
- pass
- else:
- inner += c
- skipSpace = False
- # Handle local struct definitions like QList<main(int, char**)::SomeStruct>
- inner = inner.strip()
- p = inner.find(')::')
- if p > -1:
- inner = inner[p + 3:]
- return inner
-
def putStringValue(self, value):
length, data = self.encodeStringHelper(value, self.displayStringLimit)
self.putValue(data, 'utf16', length=length)
@@ -750,10 +863,9 @@ class DumperBase():
self.putType('int')
def putEnumItem(self, name, ival, typish):
- buf = bytearray(struct.pack('i', ival))
val = self.Value(self)
- val.ldata = bytes(buf)
- val._type = self.createType(typish)
+ val.ldata = ival
+ val.typeid = self.create_typeid(typish)
with SubItem(self, name):
self.putItem(val)
@@ -826,15 +938,19 @@ class DumperBase():
def putSymbolValue(self, address):
self.putValue(self.prettySymbolByAddress(address))
- def putVTableChildren(self, item, itemCount):
- p = item.pointer()
+ def putVTableChildren(self, value, itemCount):
+ p = self.value_as_address(value)
+ entry_typeid = self.create_pointer_typeid(self.create_typeid('void'))
for i in range(itemCount):
- deref = self.extractPointer(p)
+ deref = self.extract_pointer_at_address(p)
if deref == 0:
itemCount = i
break
with SubItem(self, i):
- self.putItem(self.createPointerValue(deref, 'void'))
+ val = self.Value(self)
+ val.ldata = deref
+ val.typeid = entry_typeid
+ self.putItem(val)
p += self.ptrSize()
return itemCount
@@ -842,7 +958,9 @@ class DumperBase():
baseIndex = 0
for item in value.members(True):
if item.name is not None:
- if item.name.startswith('_vptr.') or item.name.startswith('__vfptr'):
+ if (item.name.startswith('_vptr.')
+ or item.name.startswith('_vptr$')
+ or item.name.startswith('__vfptr')):
with SubItem(self, '[vptr]'):
# int (**)(void)
self.putType(' ')
@@ -892,15 +1010,22 @@ class DumperBase():
def check(self, exp):
if not exp:
+ self.warn('Check failed: %s' % exp)
+ self.dump_location()
raise RuntimeError('Check failed: %s' % exp)
+ def check_typeid(self, typeid):
+ if not isinstance(typeid, int):
+ size = self.type_size_cache.get(typeid, None)
+ raise RuntimeError('WRONG TYPE FOR TYPEID: %s %s' % (str(typeid), type(typeid)))
+
def checkRef(self, ref):
# Assume there aren't a million references to any object.
self.check(ref >= -1)
self.check(ref < 1000000)
def checkIntType(self, thing):
- if not self.isInt(thing):
+ if not isinstance(thing, int):
raise RuntimeError('Expected an integral value, got %s' % type(thing))
def readToFirstZero(self, base, typesize, maximum):
@@ -919,7 +1044,7 @@ class DumperBase():
maximum = int(maximum / 2)
self.warn('REDUCING READING MAXIMUM TO %s' % maximum)
- #DumperBase.warn('BASE: 0x%x TSIZE: %s MAX: %s' % (base, typesize, maximum))
+ #self.warn('BASE: 0x%x TSIZE: %s MAX: %s' % (base, typesize, maximum))
for i in range(0, maximum, typesize):
t = struct.unpack_from(code, blob, i)[0]
if t == 0:
@@ -1039,11 +1164,14 @@ class DumperBase():
def putType(self, typish, priority=0):
# Higher priority values override lower ones.
if priority >= self.currentType.priority:
- types = (str) if sys.version_info[0] >= 3 else (str, unicode)
- if isinstance(typish, types):
+ if isinstance(typish, str):
self.currentType.value = typish
- else:
+ elif isinstance(typish, int):
+ self.currentType.value = self.type_name(typish)
+ elif isinstance(typish, self.Type):
self.currentType.value = typish.name
+ else:
+ self.currentType.value = str(type(typish))
self.currentType.priority = priority
def putValue(self, value, encoding=None, priority=0, length=None):
@@ -1095,23 +1223,26 @@ class DumperBase():
self.putItem(value)
def isExpanded(self):
- #DumperBase.warn('IS EXPANDED: %s in %s: %s' % (self.currentIName,
+ #self.warn('IS EXPANDED: %s in %s: %s' % (self.currentIName,
# self.expandedINames, self.currentIName in self.expandedINames))
return self.currentIName in self.expandedINames
- def mangleName(self, typeName):
+ def mangleName(self, typename):
return '_ZN%sE' % ''.join(map(lambda x: '%d%s' % (len(x), x),
- typeName.split('::')))
+ typename.split('::')))
- def arrayItemCountFromTypeName(self, typeName, fallbackMax=1):
- itemCount = typeName[typeName.find('[') + 1:typeName.find(']')]
+ def arrayItemCountFromTypeName(self, typename, fallbackMax=1):
+ itemCount = typename[typename.find('[') + 1:typename.find(']')]
return int(itemCount) if itemCount else fallbackMax
def putCStyleArray(self, value):
- arrayType = value.type.unqualified()
- innerType = arrayType.ltarget
+ arrayType = value.type
+ innerType = arrayType.target()
+ #self.warn("ARRAY TYPE: %s" % arrayType)
+ #self.warn("INNER TYPE: %s" % innerType)
if innerType is None:
- innerType = value.type.target().unqualified()
+ innerType = value.type.target()
+
address = value.address()
if address:
self.putValue('@0x%x' % address, priority=-1)
@@ -1161,19 +1292,19 @@ class DumperBase():
def cleanAddress(self, addr):
if addr is None:
return '<no address>'
- return '0x%x' % toInteger(hex(addr), 16)
+ return '0x%x' % int(hex(addr), 16)
- def stripNamespaceFromType(self, typeName):
+ def stripNamespaceFromType(self, typename):
ns = self.qtNamespace()
- if len(ns) > 0 and typeName.startswith(ns):
- typeName = typeName[len(ns):]
- # DumperBase.warn( 'stripping %s' % typeName )
+ if len(ns) > 0 and typename.startswith(ns):
+ typename = typename[len(ns):]
+ # self.warn( 'stripping %s' % typename )
lvl = 0
pos = None
stripChunks = []
- sz = len(typeName)
+ sz = len(typename)
for index in range(0, sz):
- s = typeName[index]
+ s = typename[index]
if s == '<':
lvl += 1
if lvl == 1:
@@ -1188,22 +1319,22 @@ class DumperBase():
if lvl != 0:
raise RuntimeError("unbalanced at end of type name")
for (f, l) in reversed(stripChunks):
- typeName = typeName[:f] + typeName[l:]
- return typeName
+ typename = typename[:f] + typename[l:]
+ return typename
- def tryPutPrettyItem(self, typeName, value):
+ def tryPutPrettyItem(self, typename, value):
value.check()
if self.useFancy and self.currentItemFormat() != DisplayFormat.Raw:
- self.putType(typeName)
+ self.putType(typename)
- nsStrippedType = self.stripNamespaceFromType(typeName)\
+ nsStrippedType = self.stripNamespaceFromType(typename)\
.replace('::', '__')
# Strip leading 'struct' for C structs
if nsStrippedType.startswith('struct '):
nsStrippedType = nsStrippedType[7:]
- #DumperBase.warn('STRIPPED: %s' % nsStrippedType)
+ #self.warn('STRIPPED: %s' % nsStrippedType)
# The following block is only needed for D.
if nsStrippedType.startswith('_A'):
# DMD v2.058 encodes string[] as _Array_uns long long.
@@ -1216,7 +1347,7 @@ class DumperBase():
return True
dumper = self.qqDumpers.get(nsStrippedType)
- #DumperBase.warn('DUMPER: %s' % dumper)
+ #self.warn('DUMPER: %s' % dumper)
if dumper is not None:
dumper(self, value)
return True
@@ -1242,15 +1373,15 @@ class DumperBase():
self.putField('editvalue', value)
# This is shared by pointer and array formatting.
- def tryPutSimpleFormattedPointer(self, ptr, typeName, innerType, displayFormat, limit):
+ def tryPutSimpleFormattedPointer(self, ptr, typename, innerType, displayFormat, limit):
if displayFormat == DisplayFormat.Automatic:
targetType = innerType
if innerType.code == TypeCode.Typedef:
- targetType = innerType.ltarget
+ targetType = innerType.target()
if targetType.name in ('char', 'signed char', 'unsigned char', 'uint8_t', 'CHAR'):
# Use UTF-8 as default for char *.
- self.putType(typeName)
+ self.putType(typename)
(length, shown, data) = self.readToFirstZero(ptr, 1, limit)
self.putValue(data, 'utf8', length=length)
if self.isExpanded():
@@ -1258,7 +1389,7 @@ class DumperBase():
return True
if targetType.name in ('wchar_t', 'WCHAR'):
- self.putType(typeName)
+ self.putType(typename)
charSize = self.lookupType('wchar_t').size()
(length, data) = self.encodeCArray(ptr, charSize, limit)
if charSize == 2:
@@ -1268,58 +1399,54 @@ class DumperBase():
return True
if displayFormat == DisplayFormat.Latin1String:
- self.putType(typeName)
+ self.putType(typename)
(length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'latin1', length=length)
return True
if displayFormat == DisplayFormat.SeparateLatin1String:
- self.putType(typeName)
+ self.putType(typename)
(length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'latin1', length=length)
self.putDisplay('latin1:separate', data)
return True
if displayFormat == DisplayFormat.Utf8String:
- self.putType(typeName)
+ self.putType(typename)
(length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'utf8', length=length)
return True
if displayFormat == DisplayFormat.SeparateUtf8String:
- self.putType(typeName)
+ self.putType(typename)
(length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'utf8', length=length)
self.putDisplay('utf8:separate', data)
return True
if displayFormat == DisplayFormat.Local8BitString:
- self.putType(typeName)
+ self.putType(typename)
(length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'local8bit', length=length)
return True
if displayFormat == DisplayFormat.Utf16String:
- self.putType(typeName)
+ self.putType(typename)
(length, data) = self.encodeCArray(ptr, 2, limit)
self.putValue(data, 'utf16', length=length)
return True
if displayFormat == DisplayFormat.Ucs4String:
- self.putType(typeName)
+ self.putType(typename)
(length, data) = self.encodeCArray(ptr, 4, limit)
self.putValue(data, 'ucs4', length=length)
return True
return False
- def putFormattedPointer(self, value):
- #with self.timer('formattedPointer'):
- self.putFormattedPointerX(value)
-
def putDerefedPointer(self, value):
- derefValue = value.dereference()
- innerType = value.type.target() # .unqualified()
+ derefValue = self.value_dereference(value)
+ innerType = value.type.target()
self.putType(innerType)
savedCurrentChildType = self.currentChildType
self.currentChildType = innerType.name
@@ -1332,47 +1459,47 @@ class DumperBase():
self.putItem(derefValue)
self.currentChildType = savedCurrentChildType
- def putFormattedPointerX(self, value):
+ def putFormattedPointer(self, value):
self.putOriginalAddress(value.address())
- #DumperBase.warn("PUT FORMATTED: %s" % value)
- pointer = value.pointer()
+ #self.warn("PUT FORMATTED: %s" % value)
+ pointer = self.value_as_address(value)
self.putAddress(pointer)
- #DumperBase.warn('POINTER: 0x%x' % pointer)
+ #self.warn('POINTER: 0x%x' % pointer)
if pointer == 0:
- #DumperBase.warn('NULL POINTER')
- self.putType(value.type)
+ #self.warn('NULL POINTER')
+ self.putType(value.typeid)
self.putValue('0x0')
return
- typeName = value.type.name
+ typename = self.type_name(value.typeid)
try:
self.readRawMemory(pointer, 1)
except:
# Failure to dereference a pointer should at least
# show the value of a pointer.
- #DumperBase.warn('BAD POINTER: %s' % value)
+ #self.warn('BAD POINTER: %s' % value)
self.putValue('0x%x' % pointer)
- self.putType(typeName)
+ self.putType(typename)
return
if self.currentIName.endswith('.this'):
self.putDerefedPointer(value)
return
- displayFormat = self.currentItemFormat(value.type.name)
- innerType = value.type.target() # .unqualified()
+ displayFormat = self.currentItemFormat(typename)
+ innerType = value.type.target()
if innerType.name == 'void':
- #DumperBase.warn('VOID POINTER: %s' % displayFormat)
- self.putType(typeName)
+ #self.warn('VOID POINTER: %s' % displayFormat)
+ self.putType(typename)
self.putSymbolValue(pointer)
return
if displayFormat == DisplayFormat.Raw:
# Explicitly requested bald pointer.
- #DumperBase.warn('RAW')
- self.putType(typeName)
+ #self.warn('RAW')
+ self.putType(typename)
self.putValue('0x%x' % pointer)
self.putExpandable()
if self.currentIName in self.expandedINames:
@@ -1384,27 +1511,27 @@ class DumperBase():
limit = self.displayStringLimit
if displayFormat in (DisplayFormat.SeparateLatin1String, DisplayFormat.SeparateUtf8String):
limit = 1000000
- if self.tryPutSimpleFormattedPointer(pointer, typeName,
+ if self.tryPutSimpleFormattedPointer(pointer, typename,
innerType, displayFormat, limit):
self.putExpandable()
return
if DisplayFormat.Array10 <= displayFormat and displayFormat <= DisplayFormat.Array10000:
n = (10, 100, 1000, 10000)[displayFormat - DisplayFormat.Array10]
- self.putType(typeName)
+ self.putType(typename)
self.putItemCount(n)
- self.putArrayData(value.pointer(), n, innerType)
+ self.putArrayData(self.value_as_address(value), n, innerType)
return
if innerType.code == TypeCode.Function:
# A function pointer.
self.putSymbolValue(pointer)
- self.putType(typeName)
+ self.putType(typename)
return
- #DumperBase.warn('AUTODEREF: %s' % self.autoDerefPointers)
- #DumperBase.warn('INAME: %s' % self.currentIName)
- #DumperBase.warn('INNER: %s' % innerType.name)
+ #self.warn('AUTODEREF: %s' % self.autoDerefPointers)
+ #self.warn('INAME: %s' % self.currentIName)
+ #self.warn('INNER: %s' % innerType.name)
if self.autoDerefPointers:
# Generic pointer type with AutomaticFormat, but never dereference char types:
if innerType.name not in (
@@ -1425,9 +1552,9 @@ class DumperBase():
self.putDerefedPointer(value)
return
- #DumperBase.warn('GENERIC PLAIN POINTER: %s' % value.type)
- #DumperBase.warn('ADDR PLAIN POINTER: 0x%x' % value.laddress)
- self.putType(typeName)
+ #self.warn('GENERIC PLAIN POINTER: %s' % value.type)
+ #self.warn('ADDR PLAIN POINTER: 0x%x' % value.laddress)
+ self.putType(typename)
self.putSymbolValue(pointer)
self.putExpandable()
if self.currentIName in self.expandedINames:
@@ -1458,7 +1585,7 @@ class DumperBase():
# - int postedEvents;
# - QDynamicMetaObjectData *metaObject;
# - QBindingStorage bindingStorage;
- extra = self.extractPointer(dd + 9 * ptrSize + 2 * intSize)
+ extra = self.extract_pointer_at_address(dd + 9 * ptrSize + 2 * intSize)
if extra == 0:
return False
@@ -1478,7 +1605,7 @@ class DumperBase():
# - uint isWidget : 1; etc...
# - int postedEvents;
# - QDynamicMetaObjectData *metaObject;
- extra = self.extractPointer(dd + 5 * ptrSize + 2 * intSize)
+ extra = self.extract_pointer_at_address(dd + 5 * ptrSize + 2 * intSize)
if extra == 0:
return False
@@ -1582,7 +1709,7 @@ class DumperBase():
try:
customEventOffset = 8 if self.isMsvcTarget() else 9
- customEventFunc = self.extractPointer(vtablePtr + customEventOffset * self.ptrSize())
+ customEventFunc = self.extract_pointer_at_address(vtablePtr + customEventOffset * self.ptrSize())
except:
self.bump('nostruct-3')
return False
@@ -1594,7 +1721,7 @@ class DumperBase():
customEventFunc = getJumpAddress_x86(self, customEventFunc)
if customEventFunc in (self.qtCustomEventFunc, self.qtCustomEventPltFunc):
return True
- customEventFunc = self.extractPointer(customEventFunc)
+ customEventFunc = self.extract_pointer_at_address(customEventFunc)
if customEventFunc in (self.qtCustomEventFunc, self.qtCustomEventPltFunc):
return True
# If the object is defined in another module there may be another level of indirection
@@ -1603,18 +1730,18 @@ class DumperBase():
return customEventFunc in (self.qtCustomEventFunc, self.qtCustomEventPltFunc)
# def extractQObjectProperty(objectPtr):
-# vtablePtr = self.extractPointer(objectPtr)
-# metaObjectFunc = self.extractPointer(vtablePtr)
+# vtablePtr = self.extract_pointer_at_address(objectPtr)
+# metaObjectFunc = self.extract_pointer_at_address(vtablePtr)
# cmd = '((void*(*)(void*))0x%x)((void*)0x%x)' % (metaObjectFunc, objectPtr)
# try:
-# #DumperBase.warn('MO CMD: %s' % cmd)
+# #self.warn('MO CMD: %s' % cmd)
# res = self.parseAndEvaluate(cmd)
-# #DumperBase.warn('MO RES: %s' % res)
+# #self.warn('MO RES: %s' % res)
# self.bump('successfulMetaObjectCall')
-# return res.pointer()
+# return self.value_as_address(res)
# except:
# self.bump('failedMetaObjectCall')
-# #DumperBase.warn('COULD NOT EXECUTE: %s' % cmd)
+# #self.warn('COULD NOT EXECUTE: %s' % cmd)
# return 0
def extractMetaObjectPtr(self, objectPtr, typeobj):
@@ -1631,29 +1758,29 @@ class DumperBase():
# contents 'vanishes' as the reported size of the string
# gets zeroed out(?).
# Try vtable, metaObject() is the first entry.
- vtablePtr = self.extractPointer(objectPtr)
- metaObjectFunc = self.extractPointer(vtablePtr)
+ vtablePtr = self.extract_pointer_at_address(objectPtr)
+ metaObjectFunc = self.extract_pointer_at_address(vtablePtr)
cmd = '((void*(*)(void*))0x%x)((void*)0x%x)' % (metaObjectFunc, objectPtr)
try:
- #DumperBase.warn('MO CMD: %s' % cmd)
+ #self.warn('MO CMD: %s' % cmd)
res = self.parseAndEvaluate(cmd)
- #DumperBase.warn('MO RES: %s' % res)
+ #self.warn('MO RES: %s' % res)
self.bump('successfulMetaObjectCall')
- return res.pointer()
+ return self.value_as_address(res)
except:
self.bump('failedMetaObjectCall')
- #DumperBase.warn('COULD NOT EXECUTE: %s' % cmd)
+ #self.warn('COULD NOT EXECUTE: %s' % cmd)
return 0
def extractStaticMetaObjectFromTypeHelper(someTypeObj):
if someTypeObj.isSimpleType():
return 0
- typeName = someTypeObj.name
- isQObjectProper = typeName == self.qtNamespace() + 'QObject'
+ typename = someTypeObj.name
+ isQObjectProper = typename == self.qtNamespace() + 'QObject'
# No templates for now.
- if typeName.find('<') >= 0:
+ if typename.find('<') >= 0:
return 0
result = self.findStaticMetaObject(someTypeObj)
@@ -1706,16 +1833,16 @@ class DumperBase():
ptrSize = self.ptrSize()
- typeName = typeobj.name
- result = self.knownStaticMetaObjects.get(typeName, None)
+ typename = typeobj.name
+ result = self.knownStaticMetaObjects.get(typename, None)
if result is not None: # Is 0 or the static metaobject.
self.bump('typecached')
- #DumperBase.warn('CACHED RESULT: %s %s 0x%x' % (self.currentIName, typeName, result))
+ #self.warn('CACHED RESULT: %s %s 0x%x' % (self.currentIName, typename, result))
return result
if not self.couldBeQObjectPointer(objectPtr):
self.bump('cannotBeQObject')
- #DumperBase.warn('DOES NOT LOOK LIKE A QOBJECT: %s' % self.currentIName)
+ #self.warn('DOES NOT LOOK LIKE A QOBJECT: %s' % self.currentIName)
return 0
metaObjectPtr = 0
@@ -1731,26 +1858,17 @@ class DumperBase():
#if metaObjectPtr:
# self.bump('foundMetaObject')
- # self.knownStaticMetaObjects[typeName] = metaObjectPtr
+ # self.8;
return metaObjectPtr
- def split(self, pattern, value):
- if isinstance(value, self.Value):
- return value.split(pattern)
- if self.isInt(value):
- val = self.Value(self)
- val.laddress = value
- return val.split(pattern)
- raise RuntimeError('CANNOT EXTRACT STRUCT FROM %s' % type(value))
-
def extractCString(self, addr):
result = bytearray()
while True:
- d = self.extractByte(addr)
- if d == 0:
+ d = bytes(self.readRawMemory(addr, 1))
+ if d[0] == 0:
break
- result.append(d)
+ result += d
addr += 1
return result
@@ -1775,21 +1893,21 @@ class DumperBase():
data = array + begin * stepSize
return data, size
- def putTypedPointer(self, name, addr, typeName):
+ def putTypedPointer(self, name, addr, typename):
""" Prints a typed pointer, expandable if the type can be resolved,
and without children otherwise """
with SubItem(self, name):
self.putAddress(addr)
self.putValue('@0x%x' % addr)
- typeObj = self.lookupType(typeName)
+ typeObj = self.lookupType(typename)
if typeObj:
self.putType(typeObj)
self.putExpandable()
if self.isExpanded():
with Children(self):
- self.putFields(self.createValue(addr, typeObj))
+ self.putFields(self.createValueFromAddress(addr, typeObj))
else:
- self.putType(typeName)
+ self.putType(typename)
# This is called is when a QObject derived class is expanded
def tryPutQObjectGuts(self, value):
@@ -1803,24 +1921,24 @@ class DumperBase():
stringdataOffset = ptrSize
if self.isWindowsTarget() and self.qtVersion() >= 0x060000:
stringdataOffset += ptrSize # indirect super data member
- stringdata = self.extractPointer(toInteger(metaObjectPtr) + stringdataOffset)
+ stringdata = self.extract_pointer_at_address(int(metaObjectPtr) + stringdataOffset)
- def unpackString(base, size):
+ def unpack_string(base, size):
try:
s = struct.unpack_from('%ds' % size, self.readRawMemory(base, size))[0]
- return s if sys.version_info[0] == 2 else s.decode('utf8')
+ return s.decode('utf8')
except:
return '<not available>'
if revision >= 9: # Qt 6.
pos, size = self.split('II', stringdata + 8 * index)
- return unpackString(stringdata + pos, size)
+ return unpack_string(stringdata + pos, size)
if revision >= 7: # Qt 5.
byteArrayDataSize = 24 if ptrSize == 8 else 16
- literal = stringdata + toInteger(index) * byteArrayDataSize
+ literal = stringdata + int(index) * byteArrayDataSize
base, size, _ = self.qArrayDataHelper(literal)
- return unpackString(base, size)
+ return unpack_string(base, size)
ldata = stringdata + index
return self.extractCString(ldata).decode('utf8')
@@ -1844,11 +1962,11 @@ class DumperBase():
index = name
elif self.qtVersion() >= 0x050000:
revision = 7
- dataPtr = self.extractPointer(metaObjectPtr + 2 * self.ptrSize())
+ dataPtr = self.extract_pointer_at_address(metaObjectPtr + 2 * self.ptrSize())
index = self.extractInt(dataPtr + 4 * handle)
else:
revision = 6
- dataPtr = self.extractPointer(metaObjectPtr + 2 * self.ptrSize())
+ dataPtr = self.extract_pointer_at_address(metaObjectPtr + 2 * self.ptrSize())
index = self.extractInt(dataPtr + 4 * handle)
#self.putValue("index: %s rev: %s" % (index, revision))
name = self.metaString(metaObjectPtr, index, revision)
@@ -1873,14 +1991,14 @@ class DumperBase():
def putQObjectGutsHelper(self, qobject, qobjectPtr, handle, metaObjectPtr, origType):
ptrSize = self.ptrSize()
- def putt(name, value, typeName=' '):
+ def putt(name, value, typename=' '):
with SubItem(self, name):
self.putValue(value)
- self.putType(typeName)
+ self.putType(typename)
def extractSuperDataPtr(someMetaObjectPtr):
#return someMetaObjectPtr['d']['superdata']
- return self.extractPointer(someMetaObjectPtr)
+ return self.extract_pointer_at_address(someMetaObjectPtr)
def extractDataPtr(someMetaObjectPtr):
# dataPtr = metaObjectPtr['d']['data']
@@ -1888,14 +2006,14 @@ class DumperBase():
offset = 3
else:
offset = 2
- return self.extractPointer(someMetaObjectPtr + offset * ptrSize)
+ return self.extract_pointer_at_address(someMetaObjectPtr + offset * ptrSize)
isQMetaObject = origType == 'QMetaObject'
isQObject = origType == 'QObject'
- #DumperBase.warn('OBJECT GUTS: %s 0x%x ' % (self.currentIName, metaObjectPtr))
+ #self.warn('OBJECT GUTS: %s 0x%x ' % (self.currentIName, metaObjectPtr))
dataPtr = extractDataPtr(metaObjectPtr)
- #DumperBase.warn('DATA PTRS: %s 0x%x ' % (self.currentIName, dataPtr))
+ #self.warn('DATA PTRS: %s 0x%x ' % (self.currentIName, dataPtr))
(revision, classname,
classinfo, classinfo2,
methodCount, methods,
@@ -1913,7 +2031,7 @@ class DumperBase():
ns = self.qtNamespace()
extraData = 0
if qobjectPtr:
- dd = self.extractPointer(qobjectPtr + ptrSize)
+ dd = self.extract_pointer_at_address(qobjectPtr + ptrSize)
if self.qtVersion() >= 0x60000:
(dvtablePtr, qptr, parent, children, bindingStorageData, bindingStatus,
flags, postedEvents, dynMetaObjectPtr, # Up to here QObjectData.
@@ -1942,7 +2060,7 @@ class DumperBase():
if not self.isCli:
self.putSortGroup(8)
- dvtablePtr, qptr, parentPtr, children = self.split('ppp{QList<QObject *>}', dd)
+ dvtablePtr, qptr, parentPtr, children = self.split('ppp{@QList<@QObject *>}', dd)
self.putItem(children)
if isQMetaObject:
@@ -2003,8 +2121,9 @@ class DumperBase():
if False:
with SubItem(self, '[connections]'):
if connectionListsPtr:
- typeName = '@QObjectConnectionListVector'
- self.putItem(self.createValue(connectionListsPtr, typeName))
+ typename = '@QObjectConnectionListVector'
+ self.putItem(self.createValueFromAddress(connectionListsPtr,
+typename))
else:
self.putItemCount(0)
@@ -2053,19 +2172,19 @@ class DumperBase():
if qobject and self.qtPropertyFunc:
# LLDB doesn't like calling it on a derived class, possibly
# due to type information living in a different shared object.
- #base = self.createValue(qobjectPtr, '@QObject')
- #DumperBase.warn("CALL FUNC: 0x%x" % self.qtPropertyFunc)
+ #base = self.createValueFromAddress(qobjectPtr, '@QObject')
+ #self.warn("CALL FUNC: 0x%x" % self.qtPropertyFunc)
cmd = '((QVariant(*)(void*,char*))0x%x)((void*)0x%x,"%s")' \
% (self.qtPropertyFunc, qobjectPtr, name)
try:
- #DumperBase.warn('PROP CMD: %s' % cmd)
+ #self.warn('PROP CMD: %s' % cmd)
res = self.parseAndEvaluate(cmd)
- #DumperBase.warn('PROP RES: %s' % res)
+ #self.warn('PROP RES: %s' % res)
except:
self.bump('failedMetaObjectCall')
putt(name, ' ')
continue
- #DumperBase.warn('COULD NOT EXECUTE: %s' % cmd)
+ #self.warn('COULD NOT EXECUTE: %s' % cmd)
#self.putCallItem(name, '@QVariant', base, 'property', '"' + name + '"')
if res is None:
self.bump('failedMetaObjectCall2')
@@ -2077,37 +2196,42 @@ class DumperBase():
# Dynamic properties.
if extraData:
- def list6Generator(addr, innerType):
+ def list6Generator(addr, inner_typeid):
data, size = self.listData(addr)
+ inner_size = self.type_size(inner_typeid)
for i in range(size):
- yield self.createValue(data + i * innerType.size(), innerType)
+ yield self.createValueFromAddress(data, inner_typeid)
+ data += inner_size
- def list5Generator(addr, innerType):
+ def list5Generator(addr, inner_typeid):
data, size = self.listData(addr)
for i in range(size):
- yield self.createValue(data + i * ptrSize, innerType)
+ yield self.createValueFromAddress(data, inner_typeid)
+ data += ptrSize
- def vectorGenerator(addr, innerType):
+ def vectorGenerator(addr, inner_typeid):
data, size = self.vectorData(addr)
+ inner_size = self.type_size(inner_typeid)
for i in range(size):
- yield self.createValue(data + i * innerType.size(), innerType)
+ yield self.createValueFromAddress(data, inner_typeid)
+ data += inner_size
- byteArrayType = self.createType('@QByteArray')
- variantType = self.createType('@QVariant')
+ variant_typeid = self.cheap_typeid_from_name('@QVariant')
if self.qtVersion() >= 0x60000:
- values = vectorGenerator(extraData + 3 * ptrSize, variantType)
+ values = vectorGenerator(extraData + 3 * ptrSize, variant_typeid)
elif self.qtVersion() >= 0x50600:
- values = vectorGenerator(extraData + 2 * ptrSize, variantType)
+ values = vectorGenerator(extraData + 2 * ptrSize, variant_typeid)
elif self.qtVersion() >= 0x50000:
- values = list5Generator(extraData + 2 * ptrSize, variantType)
+ values = list5Generator(extraData + 2 * ptrSize, variant_typeid)
else:
- values = list5Generator(extraData + 2 * ptrSize,
- variantType.pointer())
+ variantptr_typeid = self.cheap_typeid_from_name('@QVariant')
+ values = list5Generator(extraData + 2 * ptrSize, variantptr_typeid)
+ bytearray_typeid = self.cheap_typeid_from_name('@QByteArray')
if self.qtVersion() >= 0x60000:
- names = list6Generator(extraData, byteArrayType)
+ names = list6Generator(extraData, bytearray_typeid)
else:
- names = list5Generator(extraData + ptrSize, byteArrayType)
+ names = list5Generator(extraData + ptrSize, bytearray_typeid)
for (k, v) in zip(names, values):
with SubItem(self, propertyCount + dynamicPropertyCount):
@@ -2169,7 +2293,7 @@ class DumperBase():
if isQObject:
with SubItem(self, '[d]'):
- self.putItem(self.createValue(dd, '@QObjectPrivate'))
+ self.putItem(self.createValueFromAddress(dd, '@QObjectPrivate'))
self.putSortGroup(15)
if isQMetaObject:
@@ -2199,10 +2323,10 @@ class DumperBase():
with SubItem(self, '[connections]'):
ptrSize = self.ptrSize()
self.putNoType()
- privateType = self.createType('@QObjectPrivate')
+ privateType = self.create_typeid_from_name('@QObjectPrivate')
d_ptr = dd.cast(privateType.pointer()).dereference()
connections = d_ptr['connectionLists']
- if self.connections.integer() == 0:
+ if self.value_as_integer(connections) == 0:
self.putItemCount(0)
else:
connections = connections.dereference()
@@ -2215,72 +2339,74 @@ class DumperBase():
innerType = connections.type[0]
# Should check: innerType == ns::QObjectPrivate::ConnectionList
data, size = self.vectorData(connections)
- connectionType = self.createType('@QObjectPrivate::Connection')
+ connection_typeid = self.create_typeid_from_name('@QObjectPrivate::Connection')
+ connection_ptr_typeid = self.create_pointer_typeid(connection_typeid)
for i in range(size):
- first = self.extractPointer(data + i * 2 * ptrSize)
+ first = self.extract_pointer_at_address(data + i * 2 * ptrSize)
while first:
- self.putSubItem('%s' % pp,
- self.createPointerValue(first, connectionType))
- first = self.extractPointer(first + 3 * ptrSize)
+ val = self.Value(self)
+ val.ldata = first
+ val.typeid = connection_typeid
+ self.putSubItem('%s' % pp, val)
+ first = self.extract_pointer_at_address(first + 3 * ptrSize)
# We need to enforce some upper limit.
pp += 1
if pp > 1000:
break
- def currentItemFormat(self, typeName=None):
+ def currentItemFormat(self, typename=None):
displayFormat = self.formats.get(self.currentIName, DisplayFormat.Automatic)
if displayFormat == DisplayFormat.Automatic:
- if typeName is None:
- typeName = self.currentType.value
- needle = None if typeName is None else self.stripForFormat(typeName)
+ if typename is None:
+ typename = self.currentType.value
+ needle = None if typename is None else self.stripForFormat(typename)
displayFormat = self.typeformats.get(needle, DisplayFormat.Automatic)
return displayFormat
def putSubItem(self, component, value): # -> ReportItem
if not isinstance(value, self.Value):
raise RuntimeError('WRONG VALUE TYPE IN putSubItem: %s' % type(value))
- if not isinstance(value.type, self.Type):
- raise RuntimeError('WRONG TYPE TYPE IN putSubItem: %s' % type(value.type))
res = None
with SubItem(self, component):
self.putItem(value)
res = self.currentValue
return res # The 'short' display.
- def putArrayData(self, base, n, innerType, childNumChild=None):
+ def putArrayData(self, base, n, inner_typish, childNumChild=None):
self.checkIntType(base)
self.checkIntType(n)
- addrBase = base
- innerSize = innerType.size()
+ inner_typeid = self.typeid_for_typish(inner_typish)
+ inner_size = self.type_size_cache.get(inner_typeid, None)
self.putNumChild(n)
- #DumperBase.warn('ADDRESS: 0x%x INNERSIZE: %s INNERTYPE: %s' % (addrBase, innerSize, innerType))
- enc = innerType.simpleEncoding()
+ #self.warn('ADDRESS: 0x%x INNERSIZE: %s INNERTYPE: %s' % (base, inner_size, inner_typeid))
+ enc = self.type_encoding_cache.get(inner_typeid, None)
maxNumChild = self.maxArrayCount()
if enc:
- self.put('childtype="%s",' % innerType.name)
- self.put('addrbase="0x%x",' % addrBase)
- self.put('addrstep="0x%x",' % innerSize)
+ self.put('childtype="%s",' % self.type_name(inner_typeid))
+ self.put('addrbase="0x%x",' % base)
+ self.put('addrstep="0x%x",' % inner_size)
self.put('arrayencoding="%s",' % enc)
self.put('endian="%s",' % self.packCode)
if n > maxNumChild:
self.put('childrenelided="%s",' % n)
n = maxNumChild
self.put('arraydata="')
- self.put(self.readMemory(addrBase, n * innerSize))
+ self.put(self.readMemory(base, n * inner_size))
self.put('",')
else:
+ innerType = self.Type(self, inner_typeid)
with Children(self, n, innerType, childNumChild, maxNumChild,
- addrBase=addrBase, addrStep=innerSize):
+ addrBase=base, addrStep=inner_size):
for i in self.childRange():
- self.putSubItem(i, self.createValue(addrBase + i * innerSize, innerType))
+ self.putSubItem(i, self.createValueFromAddress(base + i * inner_size, innerType))
- def putArrayItem(self, name, addr, n, typeName):
+ def putArrayItem(self, name, addr, n, typename):
self.checkIntType(addr)
self.checkIntType(n)
with SubItem(self, name):
self.putEmptyValue()
- self.putType('%s [%d]' % (typeName, n))
- self.putArrayData(addr, n, self.lookupType(typeName))
+ self.putType('%s [%d]' % (typename, n))
+ self.putArrayData(addr, n, self.lookupType(typename))
self.putAddress(addr)
def putPlotDataHelper(self, base, n, innerType, maxNumChild=1000 * 1000):
@@ -2303,13 +2429,15 @@ class DumperBase():
"""
Special handling for char** argv.
"""
+ ptr_size = self.ptrSize()
n = 0
- p = value
- # p is 0 for "optimized out" cases. Or contains rubbish.
+ argv = self.value_as_address(value)
+ # argv is 0 for "optimized out" cases. Or contains rubbish.
try:
- if value.integer():
- while p.dereference().integer() and n <= 100:
- p += 1
+ if argv:
+ p = argv
+ while self.extract_pointer_at_address(p) and n <= 100:
+ p += ptr_size
n += 1
except:
pass
@@ -2325,44 +2453,54 @@ class DumperBase():
self.putSubItem(i, p.dereference())
p += 1
+ def extract_pointer_at_address(self, address):
+ blob = self.value_data_from_address(address, self.ptrSize())
+ return int.from_bytes(blob, byteorder='little')
+
+ def value_extract_integer(self, value, size, signed):
+ if isinstance(value.lvalue, int):
+ return value.lvalue
+ if isinstance(value.ldata, int):
+ return value.ldata
+ #with self.dumper.timer('extractInt'):
+ value.check()
+ blob = self.value_data(value, size)
+ return int.from_bytes(blob, byteorder='little', signed=signed)
+
+ def value_extract_something(self, valuish, size, signed=False):
+ if isinstance(valuish, int):
+ blob = self.value_data_from_address(valuish, size)
+ elif isinstance(valuish, self.Value):
+ blob = self.value_data(valuish, size)
+ else:
+ raise RuntimeError('CANT EXTRACT FROM %s' % type(valuish))
+ res = int.from_bytes(blob, byteorder='little', signed=signed)
+ #self.warn("EXTRACTED %s SIZE %s FROM %s" % (res, size, blob))
+ return res
+
def extractPointer(self, value):
- try:
- if value.type.code == TypeCode.Array:
- return value.address()
- except:
- pass
- code = 'I' if self.ptrSize() == 4 else 'Q'
- return self.extractSomething(value, code, 8 * self.ptrSize())
+ return self.value_extract_something(value, self.ptrSize())
def extractInt64(self, value):
- return self.extractSomething(value, 'q', 64)
+ return self.value_extract_something(value, 8, True)
def extractUInt64(self, value):
- return self.extractSomething(value, 'Q', 64)
+ return self.value_extract_something(value, 8)
def extractInt(self, value):
- return self.extractSomething(value, 'i', 32)
+ return self.value_extract_something(value, 4, True)
def extractUInt(self, value):
- return self.extractSomething(value, 'I', 32)
+ return self.value_extract_something(value, 4)
def extractShort(self, value):
- return self.extractSomething(value, 'h', 16)
+ return self.value_extract_something(value, 2, True)
def extractUShort(self, value):
- return self.extractSomething(value, 'H', 16)
+ return self.value_extract_something(value, 2)
def extractByte(self, value):
- return self.extractSomething(value, 'b', 8)
-
- def extractSomething(self, value, pattern, bitsize):
- if self.isInt(value):
- val = self.Value(self)
- val.laddress = value
- return val.extractSomething(pattern, bitsize)
- if isinstance(value, self.Value):
- return value.extractSomething(pattern, bitsize)
- raise RuntimeError('CANT EXTRACT FROM %s' % type(value))
+ return self.value_extract_something(value, 1)
# Parses a..b and a.(s).b
def parseRange(self, exp):
@@ -2405,9 +2543,9 @@ class DumperBase():
try:
# Allow integral expressions.
- ss = self.parseAndEvaluate(s[1:len(s) - 1]).integer() if s else 1
- aa = self.parseAndEvaluate(a).integer()
- bb = self.parseAndEvaluate(b).integer()
+ ss = self.value_as_integer(self.parseAndEvaluate(s[1:len(s) - 1])) if s else 1
+ aa = self.value_as_integer(self.parseAndEvaluate(a))
+ bb = self.value_as_integer(self.parseAndEvaluate(b))
if aa < bb and ss > 0:
return True, aa, ss, bb + 1, template
except:
@@ -2419,14 +2557,14 @@ class DumperBase():
self.putField('numchild', numchild)
def handleLocals(self, variables):
- #DumperBase.warn('VARIABLES: %s' % variables)
- #with self.timer('locals'):
+ #self.warn('VARIABLES: %s' % variables)
shadowed = {}
for value in variables:
if value.name == 'argv':
if value.type.code == TypeCode.Pointer:
- if value.type.ltarget.code == TypeCode.Pointer:
- if value.type.ltarget.ltarget.name == 'char':
+ target = value.type.target()
+ if target.code == TypeCode.Pointer:
+ if target.target().name == 'char':
self.putSpecialArgv(value)
continue
@@ -2455,7 +2593,7 @@ class DumperBase():
def handleWatch(self, origexp, exp, iname):
exp = str(exp).strip()
escapedExp = self.hexencode(exp)
- #DumperBase.warn('HANDLING WATCH %s -> %s, INAME: "%s"' % (origexp, exp, iname))
+ #self.warn('HANDLING WATCH %s -> %s, INAME: "%s"' % (origexp, exp, iname))
# Grouped items separated by semicolon.
if exp.find(';') >= 0:
@@ -2475,7 +2613,7 @@ class DumperBase():
# Special array index: e.g a[1..199] or a[1.(3).199] for stride 3.
isRange, begin, step, end, template = self.parseRange(exp)
if isRange:
- #DumperBase.warn('RANGE: %s %s %s in %s' % (begin, step, end, template))
+ #self.warn('RANGE: %s %s %s in %s' % (begin, step, end, template))
r = range(begin, end, step)
n = len(r)
with TopLevelItem(self, iname):
@@ -2714,7 +2852,7 @@ class DumperBase():
self.doContinue()
def doInsertInterpreterBreakpoint(self, args, wasPending):
- #DumperBase.warn('DO INSERT INTERPRETER BREAKPOINT, WAS PENDING: %s' % wasPending)
+ #self.warn('DO INSERT INTERPRETER BREAKPOINT, WAS PENDING: %s' % wasPending)
# Will fail if the service is not yet up and running.
response = self.sendInterpreterRequest('setbreakpoint', args)
bp = None if response is None else response.get('breakpoint', None)
@@ -2749,14 +2887,6 @@ class DumperBase():
def extractInterpreterStack(self):
return self.sendInterpreterRequest('backtrace', {'limit': 10})
- def isInt(self, thing):
- if isinstance(thing, int):
- return True
- if sys.version_info[0] == 2:
- if isinstance(thing, long):
- return True
- return False
-
def putItems(self, count, generator, maxNumChild=10000):
self.putItemCount(count)
if self.isExpanded():
@@ -2765,131 +2895,124 @@ class DumperBase():
self.putSubItem(i, val)
def putItem(self, value):
- #with self.timer('putItem'):
- self.putItemX(value)
-
- def putItemX(self, value):
- #DumperBase.warn('PUT ITEM: %s' % value.stringify())
-
- typeobj = value.type # unqualified()
- typeName = typeobj.name
-
- self.addToCache(typeobj) # Fill type cache
+ #self.warn('PUT ITEM: %s' % value.stringify())
+ #self.dump_location()
+ #self.addToCache(typeobj) # Fill type cache
if not value.lIsInScope:
self.putSpecialValue('optimizedout')
- #self.putType(typeobj)
- #self.putSpecialValue('outofscope')
self.putNumChild(0)
return
if not isinstance(value, self.Value):
raise RuntimeError('WRONG TYPE IN putItem: %s' % type(self.Value))
+ typeid = value.typeid
+ typecode = self.type_code(typeid)
+ typename = self.type_name(typeid)
+
# Try on possibly typedefed type first.
- if self.tryPutPrettyItem(typeName, value):
- if typeobj.code == TypeCode.Pointer:
+ if self.tryPutPrettyItem(typename, value):
+ if typecode == TypeCode.Pointer:
self.putOriginalAddress(value.address())
else:
self.putAddress(value.address())
return
- if typeobj.code == TypeCode.Typedef:
- #DumperBase.warn('TYPEDEF VALUE: %s' % value.stringify())
+ if typecode == TypeCode.Typedef:
+ #self.warn('TYPEDEF VALUE: %s' % value.stringify())
self.putItem(value.detypedef())
- self.putBetterType(typeName)
+ self.putBetterType(typename)
return
- if typeobj.code == TypeCode.Pointer:
+ if typecode == TypeCode.Pointer:
self.putFormattedPointer(value)
if value.summary and self.useFancy:
self.putValue(self.hexencode(value.summary), 'utf8:1:0')
return
self.putAddress(value.address())
- if value.lbitsize is not None:
- self.putField('size', value.lbitsize // 8)
- if typeobj.code == TypeCode.Function:
- #DumperBase.warn('FUNCTION VALUE: %s' % value)
- self.putType(typeobj)
- self.putSymbolValue(value.pointer())
+ if typecode == TypeCode.Function:
+ #self.warn('FUNCTION VALUE: %s' % value)
+ self.putType(typeid)
+ self.putSymbolValue(self.value_as_address(value))
self.putNumChild(0)
return
- if typeobj.code == TypeCode.Enum:
- #DumperBase.warn('ENUM VALUE: %s' % value.stringify())
- self.putType(typeobj.name)
+ if typecode == TypeCode.Enum:
+ #self.warn('ENUM VALUE: %s' % value.stringify())
+ self.putType(typename)
self.putValue(value.display())
self.putNumChild(0)
return
- if typeobj.code == TypeCode.Array:
- #DumperBase.warn('ARRAY VALUE: %s' % value)
+ if typecode == TypeCode.Array:
+ #self.warn('ARRAY VALUE: %s' % value)
self.putCStyleArray(value)
return
- if typeobj.code == TypeCode.Bitfield:
- #DumperBase.warn('BITFIELD VALUE: %s %d %s' % (value.name, value.lvalue, typeName))
+ if typecode == TypeCode.Bitfield:
+ #self.warn('BITFIELD VALUE: %s %d %s' % (value.name, value.lvalue, typename))
self.putNumChild(0)
- dd = typeobj.ltarget.tdata.enumDisplay
- self.putValue(str(value.lvalue) if dd is None else dd(
- value.lvalue, value.laddress, '%d'))
- self.putType(typeName)
+ #dd = typeobj.target().enumDisplay
+ #self.putValue(str(value.lvalue) if dd is None else dd(
+ # value.lvalue, value.laddress, '%d'))
+ self.putValue(self.value_as_integer(value))
+ self.putType(typename)
return
- if typeobj.code == TypeCode.Integral:
- #DumperBase.warn('INTEGER: %s %s' % (value.name, value))
- val = value.value()
+ if typecode == TypeCode.Integral:
+ #self.warn('INTEGER: %s %s' % (value.name, value))
self.putNumChild(0)
- self.putValue(val)
- self.putType(typeName)
+ self.putValue(self.value_as_integer(value))
+ self.putType(typename)
return
- if typeobj.code == TypeCode.Float:
- #DumperBase.warn('FLOAT VALUE: %s' % value)
+ if typecode == TypeCode.Float:
+ #self.warn('FLOAT VALUE: %s' % value)
self.putValue(value.value())
self.putNumChild(0)
- self.putType(typeobj.name)
+ self.putType(typename)
return
- if typeobj.code in (TypeCode.Reference, TypeCode.RValueReference):
- #DumperBase.warn('REFERENCE VALUE: %s' % value)
+ if typecode in (TypeCode.Reference, TypeCode.RValueReference):
+ #self.warn('REFERENCE VALUE: %s' % value)
val = value.dereference()
if val.laddress != 0:
self.putItem(val)
else:
self.putSpecialValue('nullreference')
- self.putBetterType(typeName)
+ self.putBetterType(typename)
return
- if typeobj.code == TypeCode.Complex:
- self.putType(typeobj)
+ if typecode == TypeCode.Complex:
+ self.putType(typeid)
self.putValue(value.display())
self.putNumChild(0)
return
- if typeobj.code == TypeCode.FortranString:
+ if typecode == TypeCode.FortranString:
self.putValue(self.hexencode(value.data()), 'latin1')
self.putNumChild(0)
- self.putType(typeobj)
+ self.putType(typeid)
- if typeName.endswith('[]'):
+ if typename.endswith('[]'):
# D arrays, gdc compiled.
n = value['length']
base = value['ptr']
- self.putType(typeName)
+ self.putType(typename)
self.putItemCount(n)
if self.isExpanded():
- self.putArrayData(base.pointer(), n, base.type.target())
+ self.putArrayData(self.value_as_address(base), n, base.type.target())
return
- #DumperBase.warn('SOME VALUE: %s' % value)
- #DumperBase.warn('GENERIC STRUCT: %s' % typeobj)
- #DumperBase.warn('INAME: %s ' % self.currentIName)
- #DumperBase.warn('INAMES: %s ' % self.expandedINames)
- #DumperBase.warn('EXPANDED: %s ' % (self.currentIName in self.expandedINames))
- self.putType(typeName)
+ #self.warn('SOME VALUE: %s' % value)
+ #self.warn('GENERIC STRUCT: %s' % typeid)
+ #self.warn('INAME: %s ' % self.currentIName)
+ #self.warn('INAMES: %s ' % self.expandedINames)
+ #self.warn('EXPANDED: %s ' % (self.currentIName in self.expandedINames))
+ self.putType(typename)
if value.summary is not None and self.useFancy:
self.putValue(self.hexencode(value.summary), 'utf8:1:0')
@@ -2898,7 +3021,7 @@ class DumperBase():
self.putExpandable()
self.putEmptyValue()
- #DumperBase.warn('STRUCT GUTS: %s ADDRESS: 0x%x ' % (value.name, value.address()))
+ #self.warn('STRUCT GUTS: %s ADDRESS: 0x%x ' % (value.name, value.address()))
if self.showQObjectNames:
#with self.timer(self.currentIName):
self.putQObjectNameValue(value)
@@ -2911,8 +3034,8 @@ class DumperBase():
self.tryPutQObjectGuts(value)
def symbolAddress(self, symbolName):
- res = self.parseAndEvaluate('(size_t)&' + symbolName)
- return None if res is None else res.pointer()
+ res = self.parseAndEvaluate('(void *)&' + symbolName)
+ return None if res is None else self.value_as_address(res)
def qtHookDataSymbolName(self):
return 'qtHookData'
@@ -2922,7 +3045,7 @@ class DumperBase():
if addr:
# Only available with Qt 5.3+
(hookVersion, x, x, x, x, x, tiVersion) = self.split('ppppppp', addr)
- #DumperBase.warn('HOOK: %s TI: %s' % (hookVersion, tiVersion))
+ #self.warn('HOOK: %s TI: %s' % (hookVersion, tiVersion))
if hookVersion >= 3:
self.qtTypeInfoVersion = lambda: tiVersion
return tiVersion
@@ -2954,16 +3077,15 @@ class DumperBase():
#self._stack = inspect.stack()
self.dumper = dumper
self.name = None
- self._type = None
+ self.typeid = None
+ self.code = None
+ self.size = None
self.ldata = None # Target address in case of references and pointers.
self.laddress = None # Own address.
self.lvalue = None
self.lIsInScope = True
self.ldisplay = None
self.summary = None # Always hexencoded UTF-8.
- self.lbitpos = None
- self.lbitsize = None
- self.targetValue = None # For references.
self.isBaseClass = None
self.nativeValue = None
self.autoDerefCount = 0
@@ -2972,49 +3094,47 @@ class DumperBase():
val = self.dumper.Value(self.dumper)
val.dumper = self.dumper
val.name = self.name
- val._type = self._type
+ val.typeid = self.typeid
+ val.code = self.code = None
+ val.size = self.size
val.ldata = self.ldata
val.laddress = self.laddress
+ val.lvalue = self.lvalue
val.lIsInScope = self.lIsInScope
val.ldisplay = self.ldisplay
val.summary = self.summary
- val.lbitpos = self.lbitpos
- val.lbitsize = self.lbitsize
- val.targetValue = self.targetValue
val.nativeValue = self.nativeValue
return val
@property
def type(self):
- if self._type is None and self.nativeValue is not None:
- self._type = self.dumper.nativeValueType(self.nativeValue)
- return self._type
+ return self.dumper.Type(self.dumper, self.typeid)
def check(self):
- if self.laddress is not None and not self.dumper.isInt(self.laddress):
- raise RuntimeError('INCONSISTENT ADDRESS: %s' % type(self.laddress))
- if self.type is not None and not isinstance(self.type, self.dumper.Type):
- raise RuntimeError('INCONSISTENT TYPE: %s' % type(self.type))
+ #if self.typeid is not None and not isinstance(self.typeid, int):
+ # raise RuntimeError('INCONSISTENT TYPE: %s' % type(self.typeid))
+ #if self.laddress is not None and not isinstance(self.laddress, int):
+ # raise RuntimeError('INCONSISTENT ADDRESS: %s' % type(self.laddress))
+ pass
def __str__(self):
#raise RuntimeError('Not implemented')
return self.stringify()
def __int__(self):
- return self.integer()
+ return self.dumper.value_as_integer(self)
def stringify(self):
addr = 'None' if self.laddress is None else ('0x%x' % self.laddress)
- return "Value(name='%s',type=%s,bsize=%s,bpos=%s,data=%s,address=%s)" \
- % (self.name, self.type.name, self.lbitsize, self.lbitpos,
- self.dumper.hexencode(self.ldata), addr)
+ if isinstance(self.ldata, int):
+ data = str(self.ldata)
+ else:
+ data = self.dumper.hexencode(self.ldata)
+ return "Value(name='%s',typeid=%s, type=%s,data=%s,address=%s)" \
+ % (self.name, self.typeid, self.type.name, data, addr)
def displayEnum(self, form='%d', bitsize=None):
- intval = self.integer(bitsize)
- dd = self.type.tdata.enumDisplay
- if dd is None:
- return str(intval)
- return dd(intval, self.laddress, form)
+ return self.dumper.value_display_enum(self, form, bitsize)
def display(self):
if self.ldisplay is not None:
@@ -3023,451 +3143,70 @@ class DumperBase():
if simple is not None:
return str(simple)
#if self.ldata is not None:
- # if sys.version_info[0] == 2 and isinstance(self.ldata, buffer):
- # return bytes(self.ldata).encode('hex')
# return self.ldata.encode('hex')
if self.laddress is not None:
return 'value of type %s at address 0x%x' % (self.type.name, self.laddress)
return '<unknown data>'
def pointer(self):
- if self.type.code == TypeCode.Typedef:
- return self.detypedef().pointer()
- return self.extractInteger(self.dumper.ptrSize() * 8, True)
-
- def integer(self, bitsize=None):
- if self.type.code == TypeCode.Typedef:
- return self.detypedef().integer()
- elif isinstance(self.lvalue, int):
- return self.lvalue
- # Could be something like 'short unsigned int'
- unsigned = self.type.name == 'unsigned' \
- or self.type.name.startswith('unsigned ') \
- or self.type.name.find(' unsigned ') != -1
- if bitsize is None:
- bitsize = self.type.lbitsize
- return self.extractInteger(bitsize, unsigned)
+ return self.dumper.value_as_address(self)
+
+ def as_address(self):
+ return self.dumper.value_as_address(self)
+
+ def integer(self):
+ return self.dumper.value_as_integer(self)
def floatingPoint(self):
- if self.nativeValue is not None and not self.dumper.isCdb:
- return str(self.nativeValue)
- if self.type.code == TypeCode.Typedef:
- return self.detypedef().floatingPoint()
- if self.type.size() == 8:
- return self.extractSomething('d', 64)
- if self.type.size() == 4:
- return self.extractSomething('f', 32)
- # Fall back in case we don't have a nativeValue at hand.
- # FIXME: This assumes Intel's 80bit extended floats. Which might
- # be wrong.
- l, h = self.split('QQ')
- if True: # 80 bit floats
- sign = (h >> 15) & 1
- exp = (h & 0x7fff)
- fraction = l
- bit63 = (l >> 63) & 1
- #DumperBase.warn("SIGN: %s EXP: %s H: 0x%x L: 0x%x" % (sign, exp, h, l))
- if exp == 0:
- if bit63 == 0:
- if l == 0:
- res = '-0' if sign else '0'
- else:
- res = (-1)**sign * l * 2**(-16382) # subnormal
- else:
- res = 'pseudodenormal'
- elif exp == 0x7fff:
- res = 'special'
- else:
- res = (-1)**sign * l * 2**(exp - 16383 - 63)
- else: # 128 bits
- sign = h >> 63
- exp = (h >> 48) & 0x7fff
- fraction = h & (2**48 - 1)
- #DumperBase.warn("SIGN: %s EXP: %s FRAC: %s H: 0x%x L: 0x%x" % (sign, exp, fraction, h, l))
- if exp == 0:
- if fraction == 0:
- res = -0.0 if sign else 0.0
- else:
- res = (-1)**sign * fraction / 2**48 * 2**(-62) # subnormal
- elif exp == 0x7fff:
- res = ('-inf' if sign else 'inf') if fraction == 0 else 'nan'
- else:
- res = (-1)**sign * (1 + fraction / 2**48) * 2**(exp - 63)
- return res
+ return self.dumper.value_as_floating_point(self)
def value(self):
- if self.type is not None:
- if self.type.code == TypeCode.Enum:
- return self.displayEnum()
- if self.type.code == TypeCode.Typedef:
- return self.detypedef().value()
- if self.type.code == TypeCode.Integral:
- return self.integer()
- if self.type.code == TypeCode.Bitfield:
- return self.integer()
- if self.type.code == TypeCode.Float:
- return self.floatingPoint()
- if self.type.code == TypeCode.Pointer:
- return self.pointer()
- return None
+ return self.dumper.value_display(self)
def extractPointer(self):
- return self.split('p')[0]
+ return self.dumper.value_extract_something(self, self.dumper.ptrSize())
def hasMember(self, name):
- return self.findMemberByName(name) is not None
+ return self.dumper.value_member_by_name(self, name) is not None
- def findMemberByName(self, name):
- self.check()
- if self.type.code == TypeCode.Typedef:
- return self.findMemberByName(self.detypedef())
- if self.type.code in (
- TypeCode.Pointer,
- TypeCode.Reference,
- TypeCode.RValueReference):
- res = self.dereference().findMemberByName(name)
- if res is not None:
- return res
- if self.type.code == TypeCode.Struct:
- #DumperBase.warn('SEARCHING FOR MEMBER: %s IN %s' % (name, self.type.name))
- members = self.members(True)
- #DumperBase.warn('MEMBERS: %s' % members)
- for member in members:
- #DumperBase.warn('CHECKING FIELD %s' % member.name)
- if member.type.code == TypeCode.Typedef:
- member = member.detypedef()
- if member.name == name:
- return member
- for member in members:
- if member.type.code == TypeCode.Typedef:
- member = member.detypedef()
- if member.name == name: # Could be base class.
- return member
- if member.type.code == TypeCode.Struct:
- res = member.findMemberByName(name)
- if res is not None:
- return res
- return None
+ def __getitem__(self, indexish):
+ return self.dumper.value_member_by_indexish(self, indexish)
- def __getitem__(self, index):
- #DumperBase.warn('GET ITEM %s %s' % (self, index))
- self.check()
- if self.type.code == TypeCode.Typedef:
- #DumperBase.warn('GET ITEM STRIP TYPEDEFS TO %s' % self.type.ltarget)
- return self.cast(self.type.ltarget).__getitem__(index)
- if isinstance(index, str):
- if self.type.code == TypeCode.Pointer:
- #DumperBase.warn('GET ITEM %s DEREFERENCE TO %s' % (self, self.dereference()))
- return self.dereference().__getitem__(index)
- res = self.findMemberByName(index)
- if res is None:
- raise RuntimeError('No member named %s in type %s'
- % (index, self.type.name))
- return res
- elif isinstance(index, self.dumper.Field):
- field = index
- elif self.dumper.isInt(index):
- if self.type.code == TypeCode.Array:
- addr = self.laddress + int(index) * self.type.ltarget.size()
- return self.dumper.createValue(addr, self.type.ltarget)
- if self.type.code == TypeCode.Pointer:
- addr = self.pointer() + int(index) * self.type.ltarget.size()
- return self.dumper.createValue(addr, self.type.ltarget)
- return self.members(False)[index]
- else:
- raise RuntimeError('BAD INDEX TYPE %s' % type(index))
- field.check()
-
- #DumperBase.warn('EXTRACT FIELD: %s, BASE 0x%x' % (field, self.address()))
- if self.type.code == TypeCode.Pointer:
- #DumperBase.warn('IS TYPEDEFED POINTER!')
- res = self.dereference()
- #DumperBase.warn('WAS POINTER: %s' % res)
-
- return field.extract(self)
-
- def extractField(self, field):
- if not isinstance(field, self.dumper.Field):
- raise RuntimeError('BAD INDEX TYPE %s' % type(field))
-
- if field.extractor is not None:
- val = field.extractor(self)
- if val is not None:
- #DumperBase.warn('EXTRACTOR SUCCEEDED: %s ' % val)
- return val
-
- if self.type.code == TypeCode.Typedef:
- return self.cast(self.type.ltarget).extractField(field)
- if self.type.code in (TypeCode.Reference, TypeCode.RValueReference):
- return self.dereference().extractField(field)
- #DumperBase.warn('FIELD: %s ' % (field,))
- val = self.dumper.Value(self.dumper)
- val.name = field.name
- val.isBaseClass = field.isBase
- val._type = field.fieldType()
-
- if field.isArtificial:
- if self.laddress is not None:
- val.laddress = self.laddress
- if self.ldata is not None:
- val.ldata = self.ldata
- return val
-
- fieldBitsize = field.bitsize
- fieldSize = (fieldBitsize + 7) // 8
- fieldBitpos = field.bitpos
- fieldOffset = fieldBitpos // 8
- fieldType = field.fieldType()
-
- if fieldType.code == TypeCode.Bitfield:
- fieldBitpos -= fieldOffset * 8
- ldata = self.data()
- data = 0
- for i in range(fieldSize):
- data = data << 8
- if self.dumper.isBigEndian:
- lbyte = ldata[i]
- else:
- lbyte = ldata[fieldOffset + fieldSize - 1 - i]
- if isinstance(lbyte, (str, bytes)):
- data += ord(lbyte)
- else:
- data += lbyte
- data = data >> fieldBitpos
- data = data & ((1 << fieldBitsize) - 1)
- val.lvalue = data
- val.laddress = None
- return val
-
- if self.laddress is not None:
- val.laddress = self.laddress + fieldOffset
- elif self.ldata is not None:
- val.ldata = self.ldata[fieldOffset:fieldOffset + fieldSize]
- else:
- self.dumper.check(False)
-
- if fieldType.code in (TypeCode.Reference, TypeCode.RValueReference):
- if val.laddress is not None:
- val = self.dumper.createReferenceValue(val.laddress, fieldType.ltarget)
- val.name = field.name
-
- #DumperBase.warn('GOT VAL %s FOR FIELD %s' % (val, field))
- val.lbitsize = fieldBitsize
- val.check()
- return val
-
- # This is the generic version for synthetic values.
- # The native backends replace it in their fromNativeValue()
- # implementations.
- def members(self, includeBases):
- #DumperBase.warn("LISTING MEMBERS OF %s" % self)
- if self.type.code == TypeCode.Typedef:
- return self.detypedef().members(includeBases)
-
- tdata = self.type.tdata
- #if isinstance(tdata.lfields, list):
- # return tdata.lfields
-
- fields = []
- if tdata.lfields is not None:
- if isinstance(tdata.lfields, list):
- fields = tdata.lfields
- else:
- fields = list(tdata.lfields(self))
-
- #DumperBase.warn("FIELDS: %s" % fields)
- res = []
- for field in fields:
- if isinstance(field, self.dumper.Value):
- #DumperBase.warn("USING VALUE DIRECTLY %s" % field.name)
- res.append(field)
- continue
- if field.isBase and not includeBases:
- #DumperBase.warn("DROPPING BASE %s" % field.name)
- continue
- res.append(self.extractField(field))
- #DumperBase.warn("GOT MEMBERS: %s" % res)
- return res
+ def members(self, include_bases):
+ return self.dumper.value_members(self, include_bases)
def __add__(self, other):
- self.check()
- if self.dumper.isInt(other):
- stripped = self.type.stripTypedefs()
- if stripped.code == TypeCode.Pointer:
- address = self.pointer() + stripped.dereference().size() * other
- val = self.dumper.Value(self.dumper)
- val.laddress = None
- val.ldata = bytes(struct.pack(self.dumper.packCode + 'Q', address))
- val._type = self._type
- return val
- raise RuntimeError('BAD DATA TO ADD TO: %s %s' % (self.type, other))
+ return self.dumper.value_plus_something(self, other)
def __sub__(self, other):
- self.check()
- if self.type.name == other.type.name:
- stripped = self.type.stripTypedefs()
- if stripped.code == TypeCode.Pointer:
- return (self.pointer() - other.pointer()) // stripped.dereference().size()
- raise RuntimeError('BAD DATA TO SUB TO: %s %s' % (self.type, other))
+ return self.dumper.value_minus_something(self, other)
def dereference(self):
- self.check()
- if self.type.code == TypeCode.Typedef:
- return self.detypedef().dereference()
- val = self.dumper.Value(self.dumper)
- if self.type.code in (TypeCode.Reference, TypeCode.RValueReference):
- val.summary = self.summary
- if self.nativeValue is None:
- val.laddress = self.pointer()
- if val.laddress is None and self.laddress is not None:
- val.laddress = self.laddress
- val._type = self.type.dereference()
- if self.dumper.useDynamicType:
- val._type = self.dumper.nativeDynamicType(val.laddress, val.type)
- else:
- val = self.dumper.nativeValueDereferenceReference(self)
- elif self.type.code == TypeCode.Pointer:
- try:
- val = self.dumper.nativeValueDereferencePointer(self)
- except:
- val.laddress = self.pointer()
- val._type = self.type.dereference()
- if self.dumper.useDynamicType:
- val._type = self.dumper.nativeDynamicType(val.laddress, val.type)
- else:
- raise RuntimeError("WRONG: %s" % self.type.code)
- #DumperBase.warn("DEREFERENCING FROM: %s" % self)
- #DumperBase.warn("DEREFERENCING TO: %s" % val)
- #dynTypeName = val.type.dynamicTypeName(val.laddress)
- #if dynTypeName is not None:
- # val._type = self.dumper.createType(dynTypeName)
- return val
+ return self.dumper.value_dereference(self)
def detypedef(self):
- self.check()
- if self.type.code != TypeCode.Typedef:
- raise RuntimeError("WRONG")
- val = self.copy()
- val._type = self.type.ltarget
- #DumperBase.warn("DETYPEDEF FROM: %s" % self)
- #DumperBase.warn("DETYPEDEF TO: %s" % val)
- return val
-
- def extend(self, size):
- if self.type.size() < size:
- val = self.dumper.Value(self.dumper)
- val.laddress = None
- val.ldata = self.zeroExtend(self.ldata)
- return val
- if self.type.size() == size:
- return self
- raise RuntimeError('NOT IMPLEMENTED')
-
- def zeroExtend(self, data, size):
- ext = '\0' * (size - len(data))
- if sys.version_info[0] == 3:
- pad = bytes(ext, encoding='latin1')
- else:
- pad = bytes(ext)
- return pad + data if self.dumper.isBigEndian else data + pad
+ return self.dumper.value_detypedef(self)
def cast(self, typish):
- self.check()
- val = self.dumper.Value(self.dumper)
- val.laddress = self.laddress
- val.lbitsize = self.lbitsize
- val.ldata = self.ldata
- val._type = self.dumper.createType(typish)
- return val
+ return self.dumper.value_cast(self, typish)
def address(self):
self.check()
return self.laddress
- def data(self, size=None):
- self.check()
- if self.ldata is not None:
- if len(self.ldata) > 0:
- if size is None:
- return self.ldata
- if size == len(self.ldata):
- return self.ldata
- if size < len(self.ldata):
- return self.ldata[:size]
- #raise RuntimeError('ZERO-EXTENDING DATA TO %s BYTES: %s' % (size, self))
- return self.zeroExtend(self.ldata, size)
- if self.laddress is not None:
- if size is None:
- size = self.type.size()
- res = self.dumper.readRawMemory(self.laddress, size)
- if len(res) > 0:
- return res
- raise RuntimeError('CANNOT CONVERT ADDRESS TO BYTES: %s' % self)
- raise RuntimeError('CANNOT CONVERT TO BYTES: %s' % self)
-
- def extractInteger(self, bitsize, unsigned):
- #with self.dumper.timer('extractInt'):
- self.check()
- if bitsize > 32:
- size = 8
- code = 'Q' if unsigned else 'q'
- elif bitsize > 16:
- size = 4
- code = 'I' if unsigned else 'i'
- elif bitsize > 8:
- size = 2
- code = 'H' if unsigned else 'h'
- else:
- size = 1
- code = 'B' if unsigned else 'b'
- rawBytes = self.data(size)
- res = struct.unpack_from(self.dumper.packCode + code, rawBytes, 0)[0]
- #DumperBase.warn('Extract: Code: %s Bytes: %s Bitsize: %s Size: %s'
- # % (self.dumper.packCode + code, self.dumper.hexencode(rawBytes), bitsize, size))
- return res
-
- def extractSomething(self, code, bitsize):
- #with self.dumper.timer('extractSomething'):
- self.check()
- size = (bitsize + 7) >> 3
- rawBytes = self.data(size)
- res = struct.unpack_from(self.dumper.packCode + code, rawBytes, 0)[0]
- return res
+ def data(self):
+ return self.dumper.value_data(self, self.dumper.type_size(self.typeid))
def to(self, pattern):
return self.split(pattern)[0]
def split(self, pattern):
- #with self.dumper.timer('split'):
- #DumperBase.warn('EXTRACT STRUCT FROM: %s' % self.type)
- (pp, size, fields) = self.dumper.describeStruct(pattern)
- #DumperBase.warn('SIZE: %s ' % size)
- result = struct.unpack_from(self.dumper.packCode + pp, self.data(size))
-
- def structFixer(field, thing):
- #DumperBase.warn('STRUCT MEMBER: %s' % type(thing))
- if field.isStruct:
- #if field.type != field.fieldType():
- # raise RuntimeError('DO NOT SIMPLIFY')
- #DumperBase.warn('FIELD POS: %s' % field.type.stringify())
- #DumperBase.warn('FIELD TYE: %s' % field.fieldType().stringify())
- res = self.dumper.createValue(thing, field.fieldType())
- #DumperBase.warn('RES TYPE: %s' % res.type)
- if self.laddress is not None:
- res.laddress = self.laddress + field.offset()
- return res
- return thing
- if len(fields) != len(result):
- raise RuntimeError('STRUCT ERROR: %s %s' % (fields, result))
- return tuple(map(structFixer, fields, result))
+ return self.dumper.value_split(self, pattern)
def checkPointer(self, p, align=1):
- ptr = p if self.isInt(p) else p.pointer()
+ ptr = p if isinstance(p, int) else p.pointer()
self.readRawMemory(ptr, 1)
- def type(self, typeId):
- return self.typeData.get(typeId)
-
def splitArrayType(self, type_name):
# "foo[2][3][4]" -> ("foo", "[3][4]", 2)
pos1 = len(type_name)
@@ -3481,249 +3220,171 @@ class DumperBase():
item_count = type_name[pos1 + 1:pos2]
return (type_name[0:pos1].strip(), type_name[pos2 + 1:].strip(), int(item_count))
- def registerTypeAlias(self, existingTypeId, aliasId):
- #DumperBase.warn('REGISTER ALIAS %s FOR %s' % (aliasId, existingTypeId))
- self.typeData[aliasId] = self.typeData[existingTypeId]
-
- class TypeData():
- def __init__(self, dumper, type_id):
- self.dumper = dumper
- self.lfields = None # None or Value -> list of member Values
- self.lalignment = None # Function returning alignment of this struct
- self.lbitsize = None
- self.ltarget = None # Inner type for arrays
- self.templateArguments = None
- self.code = None
- self.name = type_id
- self.typeId = type_id
- self.enumDisplay = None
- self.moduleName = None
- #DumperBase.warn('REGISTER TYPE: %s' % type_id)
- dumper.typeData[type_id] = self
-
- def copy(self):
- tdata = self.dumper.TypeData(self.dumper, self.typeId)
- tdata.dumper = self.dumper
- tdata.lfields = self.lfields
- tdata.lalignment = self.lalignment
- tdata.lbitsize = self.lbitsize
- tdata.ltarget = self.ltarget
- tdata.templateArguments = self.templateArguments
- tdata.code = self.code
- tdata.name = self.name
- tdata.typeId = self.typeId
- tdata.enumDisplay = self.enumDisplay
- tdata.moduleName = self.moduleName
- return tdata
-
- @property
- def bitsize(self):
- if callable(self.lbitsize):
- self.lbitsize = self.lbitsize()
- return self.lbitsize
+ def registerTypeAlias(self, existing_type_id, alias_id):
+ #self.warn('REGISTER ALIAS %s FOR %s' % (aliasId, existingTypeId))
+ self.type_alias[alias_id] = existing_type_id
+
+ def init_type_cache(self):
+ self.type_name_cache = {}
+ self.type_fields_cache = {}
+ self.type_alignment_cache = {}
+ self.type_bitsize_cache = {}
+ self.type_size_cache = {}
+ self.type_target_cache = {}
+ self.type_template_arguments_cache = {}
+ self.type_code_cache = {}
+ self.type_enum_display_cache = {}
+ self.type_module_name_cache = {}
+ self.type_nativetype_cache = {}
+ self.type_modulename_cache = {}
+ self.type_encoding_cache = {}
+ self.typeid_cache = {} # internal typename -> id
+ self.typeid_current = 100
+ self.typeid_from_typekey = {} # typename -> id
+
+ def dump_type_cache(self):
+ self.warn('NAME: %s' % self.type_name_cache)
+ self.warn('CODE: %s' % self.type_code_cache)
+ #self.warn('FIELDS: %s' % self.type_fields_cache)
+ self.warn('SIZE: %s' % self.type_size_cache)
+ self.warn('TARGS: %s' % self.type_template_arguments_cache)
+ self.warn('BITSIZE: %s' % self.type_bitsize_cache)
+ self.warn('TARGET: %s' % self.type_target_cache)
+ #self.warn('NATIVETYPE: %s' % self.type_nativetype_cache)
+
+ def dump_typeid(self, typeid):
+ self.warn(' NAME: %s' % self.type_name_cache.get(typeid, None))
+ self.warn(' CODE: %s' % self.type_code_cache.get(typeid, None))
+ #self.warn(' FIELDS: %s' % self.type_fields_cache.get(typeid, None))
+ self.warn(' SIZE: %s' % self.type_size_cache.get(typeid, None))
+ self.warn(' TARGS: %s' % self.type_template_arguments_cache.get(typeid, None))
+ self.warn(' BITSIZE: %s' % self.type_bitsize_cache.get(typeid, None))
+ self.warn(' TARGET: %s' % self.type_target_cache.get(typeid, None))
+ #self.warn(' NATIVETYPE: %s' % self.type_nativetype_cache.get(typeid, None))
+
+ def typeid_for_typish(self, typish):
+ if isinstance(typish, int):
+ return typish
+ if isinstance(typish, str):
+ return self.typeid_for_string(typish)
+ if isinstance(typish, self.Type):
+ return typish.typeid
+ self.warn('NO TYPE FOR TYPISH: %s' % str(typish))
+ return 0
+
+ def sanitize_type_name(self, typeid_str):
+ if not ' ' in typeid_str:
+ # FIXME: This uses self.qtNamespace() too early.
+ #typeid_arr.append(self.qtNamespace())
+ return typeid_str.replace('@', '')
+ typeid_arr = []
+ last_char_was_space = False
+ for c in typeid_str:
+ if c == '@' in typeid_str:
+ # FIXME: This uses self.qtNamespace() too early.
+ #typeid_arr.append(self.qtNamespace())
+ pass
+ elif c == ' ':
+ last_char_was_space = True
+ elif c in '&*<>,':
+ last_char_was_space = False
+ typeid_arr.append(c)
+ else:
+ if last_char_was_space:
+ typeid_arr.append(' ')
+ last_char_was_space = False
+ typeid_arr.append(c)
+ #self.warn("SANITIZE: '%s' TO '%s'" % (typeid_str, ''.join(typeid_arr)))
+ return ''.join(typeid_arr)
+
+ def typeid_for_string(self, typeid_str, type_name=None):
+ #typeid = self.typeid_cache.get(typeid_str, None)
+ #if typeid is not None:
+ # return typeid
+ sane_typeid_str = self.sanitize_type_name(typeid_str)
+ typeid = self.typeid_cache.get(sane_typeid_str, None)
+ if typeid is not None:
+ return typeid
+
+ self.typeid_current += 1
+ if type_name is None:
+ type_name = sane_typeid_str
+ typeid = self.typeid_current
+ self.typeid_cache[typeid_str] = typeid
+ self.typeid_cache[sane_typeid_str] = typeid
+ self.type_name_cache[typeid] = type_name
+ #if typeid == 103:
+ #self.warn("CREATED TYPE: %d %s" % (typeid, sane_typeid_str))
+ #if typeid == 135: self.dump_location()
+ return typeid
class Type():
- def __init__(self, dumper, typeId):
- self.typeId = typeId.replace('@', dumper.qtNamespace())
+ __slots__ = ['dumper', 'typeid']
+ def __init__(self, dumper, typeid):
self.dumper = dumper
- self.initialized = False
+ self.typeid = typeid
def __str__(self):
- #return self.typeId
- return self.stringify()
-
- @property
- def tdata(self):
- if not self.initialized:
- self.initialized = True
- self.data = self.dumper.typeData.get(self.typeId, None)
- if self.data is None:
- #DumperBase.warn('USING : %s' % self.typeId)
- self.dumper.lookupType(self.typeId)
- self.data = self.dumper.typeData.get(self.typeId)
- return self.data
-
- def setTdata(self, tdata):
- self.initialized = True
- self.data = tdata
+ return self.dumper.type_stringify(self.typeid)
@property
def name(self):
- return self.typeId if self.tdata is None else self.tdata.name
+ return self.dumper.type_name(self.typeid)
@property
def code(self):
- return self.tdata.code
+ return self.dumper.type_code(self.typeid)
- @property
- def lbitsize(self):
- return self.tdata.bitsize
+ def bitsize(self):
+ return self.dumper.type_bitsize(self.typeid)
- @property
- def lbitpos(self):
- return self.tdata.lbitpos
+ def size(self):
+ return self.dumper.type_size(self.typeid)
- @property
- def ltarget(self):
- if isinstance(self.tdata.ltarget, str):
- self.tdata.ltarget = self.dumper.createType(self.tdata.ltarget)
- return self.tdata.ltarget
+ def target(self):
+ return self.dumper.Type(self.dumper, self.dumper.type_target(self.typeid))
@property
def targetName(self):
- if self.tdata.ltarget is None:
+ target = self.target()
+ if target is None:
return ''
- return self.tdata.ltarget if isinstance(self.tdata.ltarget, str) else self.tdata.ltarget.name
+ return target if isinstance(target, str) else target.name
@property
def moduleName(self):
- if callable(self.tdata.moduleName):
- self.tdata.moduleName = self.tdata.moduleName()
- return self.tdata.moduleName
-
- def stringify(self):
- return 'Type(name="%s",bsize=%s,code=%s)' \
- % (self.tdata.name, self.lbitsize, self.tdata.code)
+ return self.dumper.type_modulename_cache.get(self.typeid, None)
def __getitem__(self, index):
- if self.dumper.isInt(index):
- return self.templateArgument(index)
+ if isinstance(index, int):
+ return self.dumper.type_template_argument(self.typeid, index)
raise RuntimeError('CANNOT INDEX TYPE')
- def dynamicTypeName(self, address):
- if self.tdata.code != TypeCode.Struct:
- return None
- try:
- vtbl = self.dumper.extractPointer(address)
- except:
- return None
- #DumperBase.warn('VTBL: 0x%x' % vtbl)
- if not self.dumper.couldBePointer(vtbl):
- return None
- return self.dumper.nativeDynamicTypeName(address, self)
-
- def dynamicType(self, address):
- # FIXME: That buys some performance at the cost of a fail
- # of Gdb13393 dumper test.
- #return self
- #with self.dumper.timer('dynamicType %s 0x%s' % (self.name, address)):
- dynTypeName = self.dynamicTypeName(address)
- if dynTypeName is not None:
- return self.dumper.createType(dynTypeName)
- return self
-
def check(self):
- if self.tdata.name is None:
- raise RuntimeError('TYPE WITHOUT NAME: %s' % self.typeId)
+ #if self.tdata.name is None:
+ # raise RuntimeError('TYPE WITHOUT NAME: %s' % self.typeid)
+ pass
def dereference(self):
- if self.code == TypeCode.Typedef:
- return self.ltarget.dereference()
- self.check()
- return self.ltarget
-
- def unqualified(self):
- return self
+ return self.dumper.Type(self.dumper, self.dumper.type_dereference(self.typeid))
def templateArguments(self):
- if self.tdata is None:
- return self.dumper.listTemplateParameters(self.typeId)
- return self.tdata.templateArguments()
-
- def templateArgument(self, position):
- #DumperBase.warn('TDATA: %s' % self.tdata)
- #DumperBase.warn('ID: %s' % self.typeId)
- if self.tdata is None or self.tdata.templateArguments is None:
- # Native lookups didn't help. Happens for 'wrong' placement of 'const'
- # etc. with LLDB. But not all is lost:
- ta = self.dumper.listTemplateParameters(self.typeId)
- #DumperBase.warn('MANUAL: %s' % ta)
- res = ta[position]
- #DumperBase.warn('RES: %s' % res.typeId)
- return res
- #DumperBase.warn('TA: %s %s' % (position, self.typeId))
- #DumperBase.warn('ARGS: %s' % self.tdata.templateArguments())
- return self.tdata.templateArguments()[position]
-
- def simpleEncoding(self):
- res = {
- 'bool': 'int:1',
- 'char': 'int:1',
- 'int8_t': 'int:1',
- 'qint8': 'int:1',
- 'signed char': 'int:1',
- 'char8_t': 'uint:1',
- 'unsigned char': 'uint:1',
- 'uint8_t': 'uint:1',
- 'quint8': 'uint:1',
- 'short': 'int:2',
- 'int16_t': 'int:2',
- 'qint16': 'int:2',
- 'unsigned short': 'uint:2',
- 'char16_t': 'uint:2',
- 'uint16_t': 'uint:2',
- 'quint16': 'uint:2',
- 'int': 'int:4',
- 'int32_t': 'int:4',
- 'qint32': 'int:4',
- 'unsigned int': 'uint:4',
- 'char32_t': 'uint:4',
- 'uint32_t': 'uint:4',
- 'quint32': 'uint:4',
- 'long long': 'int:8',
- 'int64_t': 'int:8',
- 'qint64': 'int:8',
- 'unsigned long long': 'uint:8',
- 'uint64_t': 'uint:8',
- 'quint64': 'uint:8',
- 'float': 'float:4',
- 'double': 'float:8',
- 'QChar': 'uint:2'
- }.get(self.name, None)
- return res
+ return self.dumper.type_template_arguments(self.typeid)
+
+ def templateArgument(self, index):
+ return self.dumper.type_template_argument(self.typeid, index)
def isSimpleType(self):
return self.code in (TypeCode.Integral, TypeCode.Float, TypeCode.Enum)
def alignment(self):
- if self.tdata.code == TypeCode.Typedef:
- return self.ltarget.alignment()
- if self.tdata.code in (TypeCode.Integral, TypeCode.Float, TypeCode.Enum):
- if self.tdata.name in ('double', 'long long', 'unsigned long long'):
- # Crude approximation.
- return 8 if self.dumper.isWindowsTarget() else self.dumper.ptrSize()
- return self.size()
- if self.tdata.code in (TypeCode.Pointer, TypeCode.Reference, TypeCode.RValueReference):
- return self.dumper.ptrSize()
- if self.tdata.lalignment is not None:
- #if isinstance(self.tdata.lalignment, function): # Does not work that way.
- if hasattr(self.tdata.lalignment, '__call__'):
- return self.tdata.lalignment()
- return self.tdata.lalignment
- return 1
+ return self.dumper.type_alignment(self.typeid)
def pointer(self):
- return self.dumper.createPointerType(self)
-
- def target(self):
- return self.ltarget
+ return self.dumper.Type(self.dumper, self.dumper.create_pointer_typeid(self.typeid))
def stripTypedefs(self):
- if isinstance(self, self.dumper.Type) and self.code != TypeCode.Typedef:
- #DumperBase.warn('NO TYPEDEF: %s' % self)
- return self
- return self.ltarget
-
- def size(self):
- bs = self.lbitsize
- if bs % 8 != 0:
- DumperBase.warn('ODD SIZE: %s' % self)
- return (7 + bs) >> 3
-
- def bitsize(self):
- if self.lbitsize is not None:
- return self.lbitsize
- raise RuntimeError('DONT KNOW SIZE: %s' % self)
+ return self.dumper.Type(self.dumper, self.dumper.type_target(self.typeid))
def isMovableType(self):
if self.code in (TypeCode.Pointer, TypeCode.Integral, TypeCode.Float):
@@ -3748,264 +3409,195 @@ class DumperBase():
return self.dumper.qtVersion() >= 0x050600
return False
- class Field(collections.namedtuple('Field',
- ['dumper', 'name', 'type', 'bitsize', 'bitpos',
- 'extractor', 'isBase', 'isStruct', 'isArtificial'])):
+ class Field:
+ __slots__ = ['name', 'typeid', 'bitsize', 'bitpos', 'is_struct', 'is_artificial', 'is_base_class']
- def __new__(cls, dumper, name=None, type=None, bitsize=None, bitpos=None,
- extractor=None, isBase=False, isStruct=False, isArtificial=False):
- return super(DumperBase.Field, cls).__new__(
- cls, dumper, name, type, bitsize, bitpos,
- extractor, isBase, isStruct, isArtificial)
+ def __init__(self, name=None, typeid=None, bitsize=None, bitpos=None,
+ extractor=None, is_struct=False, is_artificial=False, is_base_class=False):
+ self.name = name
+ self.typeid = typeid
+ self.bitsize = bitsize
+ self.bitpos = bitpos
+ self.is_struct = is_struct
+ self.is_base_class = is_base_class
- __slots__ = ()
-
- def __str__(self):
- return self.stringify()
-
- def stringify(self):
- #return 'Field(name="%s")' % self.name
- typename = None if self.type is None else self.type.stringify()
- return 'Field(name="%s",type=%s,bitpos=%s,bitsize=%s)' \
- % (self.name, typename, self.bitpos, self.bitsize)
-
- def check(self):
- pass
-
- def size(self):
- return self.bitsize() // 8
-
- def offset(self):
- return self.bitpos // 8
-
- def fieldType(self):
- if self.type is not None:
- return self.type
- raise RuntimeError('CANT GET FIELD TYPE FOR %s' % self)
- return None
def ptrCode(self):
return 'I' if self.ptrSize() == 4 else 'Q'
- def toPointerData(self, address):
- if not self.isInt(address):
- raise RuntimeError('wrong')
- return bytes(struct.pack(self.packCode + self.ptrCode(), address))
-
def fromPointerData(self, bytes_value):
return struct.unpack(self.packCode + self.ptrCode(), bytes_value)
- def createPointerValue(self, targetAddress, targetTypish):
- if not isinstance(targetTypish, self.Type) and not isinstance(targetTypish, str):
- raise RuntimeError('Expected type in createPointerValue(), got %s'
- % type(targetTypish))
- if not self.isInt(targetAddress):
+ def createPointerValue(self, target_address, target_typish):
+ if not isinstance(target_address, int):
raise RuntimeError('Expected integral address value in createPointerValue(), got %s'
- % type(targetTypish))
+ % type(target_typish))
val = self.Value(self)
- val.ldata = self.toPointerData(targetAddress)
- targetType = self.createType(targetTypish)
- if self.useDynamicType:
- targetType = targetType.dynamicType(targetAddress)
- val._type = self.createPointerType(targetType)
+ val.ldata = target_address
+ val.typeid = self.create_pointer_typeid(self.create_typeid(target_typish))
return val
-
- def createReferenceValue(self, targetAddress, targetType):
- if not isinstance(targetType, self.Type):
- raise RuntimeError('Expected type in createReferenceValue(), got %s'
- % type(targetType))
- if not self.isInt(targetAddress):
- raise RuntimeError('Expected integral address value in createReferenceValue(), got %s'
- % type(targetType))
- val = self.Value(self)
- val.ldata = self.toPointerData(targetAddress)
- if self.useDynamicType:
- targetType = targetType.dynamicType(targetAddress)
- val._type = self.createReferenceType(targetType)
- return val
-
- def createPointerType(self, targetType):
- if not isinstance(targetType, (str, self.Type)):
- raise RuntimeError('Expected type or str in createPointerType(), got %s'
- % type(targetType))
- typeId = (targetType if isinstance(targetType, str) else targetType.typeId) + ' *'
- tdata = self.TypeData(self, typeId)
- tdata.name = (targetType if isinstance(targetType, str) else targetType.name) + '*'
- tdata.lbitsize = 8 * self.ptrSize()
- tdata.code = TypeCode.Pointer
- tdata.ltarget = targetType
- return self.Type(self, typeId)
-
- def createReferenceType(self, targetType):
- if not isinstance(targetType, self.Type):
- raise RuntimeError('Expected type in createReferenceType(), got %s'
- % type(targetType))
- typeId = targetType.typeId + ' &'
- tdata = self.TypeData(self, typeId)
- tdata.name = targetType.name + ' &'
- tdata.code = TypeCode.Reference
- tdata.ltarget = targetType
- tdata.lbitsize = 8 * self.ptrSize() # Needed for Gdb13393 test.
- #tdata.lbitsize = None
- return self.Type(self, typeId)
-
- def createRValueReferenceType(self, targetType):
- if not isinstance(targetType, self.Type):
- raise RuntimeError('Expected type in createRValueReferenceType(), got %s'
- % type(targetType))
- typeId = targetType.typeId + ' &&'
- tdata = self.TypeData(self, typeId)
- tdata.name = targetType.name + ' &&'
- tdata.code = TypeCode.RValueReference
- tdata.ltarget = targetType
- tdata.lbitsize = None
- return self.Type(self, typeId)
-
- def createArrayType(self, targetType, count):
- if not isinstance(targetType, self.Type):
- raise RuntimeError('Expected type in createArrayType(), got %s'
- % type(targetType))
- targetTypeId = targetType.typeId
-
- if targetTypeId.endswith(']'):
- (prefix, suffix, inner_count) = self.splitArrayType(targetTypeId)
- type_id = '%s[%d][%d]%s' % (prefix, count, inner_count, suffix)
- type_name = type_id
+ #target_typeid = self.create_typeid(target_typish)
+ #if self.useDynamicType:
+ # target_typeid = self.dynamic_typeid_at_address(target_typeid, target_address)
+ #val.typeid = self.create_pointer_typeid(target_typeid)
+ #return val
+
+ def createPointerType(self, target_typish):
+ typeid = self.create_pointer_typeid(self.typeid_for_typish(target_typish))
+ return self.Type(self, typeid)
+
+ def create_pointer_typeid(self, target_typeid):
+ name = self.type_name(target_typeid) + ' *'
+ typeid = self.typeid_for_string(name)
+ self.type_size_cache[typeid] = self.ptrSize()
+ self.type_alignment_cache[typeid] = self.ptrSize()
+ self.type_code_cache[typeid] = TypeCode.Pointer
+ self.type_target_cache[typeid] = target_typeid
+ return typeid
+
+ def create_reference_typeid(self, target_typeid):
+ type_name = self.type_name_cache[target_typeid] + ' &'
+ typeid = self.typeid_for_string(type_name)
+ self.type_code_cache[typeid] = TypeCode.Reference
+ self.type_target_cache[typeid] = target_typeid
+ #self.type_size_cache[typeid] = self.ptrSize() # Needed for Gdb13393 test.
+ return typeid
+
+ def create_rvalue_reference_typeid(self, target_typeid):
+ type_name = self.type_name_cache[target_typeid] + ' &&'
+ typeid = self.typeid_for_string(type_name)
+ self.type_code_cache[typeid] = TypeCode.RValueReference
+ self.type_target_cache[typeid] = target_typeid
+ return typeid
+
+ def create_array_typeid(self, target_typeid, count):
+ target_type_name = self.type_name(target_typeid)
+ if target_type_name.endswith(']'):
+ (prefix, suffix, inner_count) = self.splitArrayType(target_type_name)
+ type_name = '%s[%d][%d]%s' % (prefix, count, inner_count, suffix)
else:
- type_id = '%s[%d]' % (targetTypeId, count)
- type_name = '%s[%d]' % (targetType.name, count)
-
- tdata = self.TypeData(self, type_id)
- tdata.name = type_name
- tdata.code = TypeCode.Array
- tdata.ltarget = targetType
- tdata.lbitsize = targetType.lbitsize * count
- return self.Type(self, type_id)
-
- def createBitfieldType(self, targetType, bitsize):
- if not isinstance(targetType, self.Type):
- raise RuntimeError('Expected type in createBitfieldType(), got %s'
- % type(targetType))
- typeId = '%s:%d' % (targetType.typeId, bitsize)
- tdata = self.TypeData(self, typeId)
- tdata.name = '%s : %d' % (targetType.typeId, bitsize)
- tdata.code = TypeCode.Bitfield
- tdata.ltarget = targetType
- tdata.lbitsize = bitsize
- return self.Type(self, typeId)
-
- def createTypedefedType(self, targetType, typeName, typeId=None):
- if typeId is None:
- typeId = typeName
- if not isinstance(targetType, self.Type):
- raise RuntimeError('Expected type in createTypedefType(), got %s'
- % type(targetType))
+ type_name = '%s[%d]' % (target_type_name, count)
+ typeid = self.typeid_for_string(type_name)
+ self.type_code_cache[typeid] = TypeCode.Array
+ self.type_target_cache[typeid] = target_typeid
+ self.type_size_cache[typeid] = self.type_size(target_typeid) * count
+ self.type_alignment_cache[typeid] = self.type_alignment_cache.get(target_typeid, None)
+ return typeid
+
+ def create_bitfield_typeid(self, target_typeid, bitsize):
+ target_typename = self.type_name(target_typeid)
+ typeid = self.typeid_for_string('%s:%d' % (target_typename, bitsize))
+ self.type_name_cache[typeid] = '%s : %d' % (target_typename, bitsize)
+ self.type_code_cache[typeid] = TypeCode.Bitfield
+ self.type_target_cache[typeid] = target_typeid
+ self.type_bitsize_cache[typeid] = bitsize
+ return typeid
+
+ def create_typedefed_typeid(self, target_typeid, type_name, type_key):
+ typeid = self.typeid_for_string(type_key, type_name)
# Happens for C-style struct in GDB: typedef { int x; } struct S1;
- if targetType.typeId == typeId:
- return targetType
- tdata = self.TypeData(self, typeId)
- tdata.name = typeName
- tdata.code = TypeCode.Typedef
- tdata.ltarget = targetType
- tdata.lbitsize = targetType.lbitsize
- #tdata.lfields = targetType.lfields
- tdata.lbitsize = targetType.lbitsize
- return self.Type(self, typeId)
-
- def knownArrayTypeSize(self):
- return 3 * self.ptrSize() if self.qtVersion() >= 0x060000 else self.ptrSize()
-
- def knownTypeSize(self, typish):
- if typish[0] == 'Q':
- if typish.startswith('QList<') or typish.startswith('QVector<'):
- return self.knownArrayTypeSize()
- if typish == 'QObject':
- return 2 * self.ptrSize()
- if typish == 'QStandardItemData':
- return 4 * self.ptrSize() if self.qtVersion() >= 0x060000 else 2 * self.ptrSize()
- if typish == 'Qt::ItemDataRole':
- return 4
- if typish == 'QChar':
- return 2
- if typish in ('quint32', 'qint32'):
- return 4
- return None
+ if target_typeid == typeid:
+ return target_typeid
+ self.type_code_cache[typeid] = TypeCode.Typedef
+ self.type_target_cache[typeid] = target_typeid
+ self.type_size_cache[typeid] = self.type_size_cache.get(target_typeid, None)
+ return typeid
def createType(self, typish, size=None):
- if isinstance(typish, self.Type):
- #typish.check()
- if hasattr(typish, 'lbitsize') and typish.lbitsize is not None and typish.lbitsize > 0:
- return typish
- # Size 0 is sometimes reported by GDB but doesn't help at all.
- # Force using the fallback:
- typish = typish.name
+ return self.Type(self, self.create_typeid(typish, size))
+ def create_typeid(self, typish, size=None):
+ if isinstance(typish, int):
+ return typish
+ if isinstance(typish, self.Type):
+ return typish.typeid
if isinstance(typish, str):
- ns = self.qtNamespace()
- typish = typish.replace('@', ns)
- if typish.startswith(ns):
- if size is None:
- size = self.knownTypeSize(typish[len(ns):])
- else:
- if size is None:
- size = self.knownTypeSize(typish)
- if size is not None:
- typish = ns + typish
-
- tdata = self.typeData.get(typish, None)
- if tdata is not None:
- if tdata.lbitsize is not None:
- if callable(tdata.lbitsize) or tdata.lbitsize > 0:
- return self.Type(self, typish)
-
- knownType = self.lookupType(typish)
- #DumperBase.warn('KNOWN: %s' % knownType)
- if knownType is not None:
- #DumperBase.warn('USE FROM NATIVE')
- return knownType
-
- #DumperBase.warn('FAKING: %s SIZE: %s' % (typish, size))
- tdata = self.TypeData(self, typish)
- tdata.templateArguments = lambda: self.listTemplateParameters(typish)
- if size is not None:
- tdata.lbitsize = 8 * size
- if typish.endswith('*'):
- tdata.code = TypeCode.Pointer
- tdata.lbitsize = 8 * self.ptrSize()
- tdata.ltarget = typish[:-1].strip()
-
- typeobj = self.Type(self, tdata.typeId)
- #DumperBase.warn('CREATE TYPE: %s' % typeobj.stringify())
- typeobj.check()
- return typeobj
+ return self.create_typeid_from_name(typish)
raise RuntimeError('NEED TYPE, NOT %s' % type(typish))
- def createValueFromAddressAndType(self, address, typish):
+ def cheap_typeid_from_name(self, typename_):
+ ns = self.qtNamespace()
+ typename = typename_.replace('@', ns)
+ return self.cheap_typeid_from_name_nons(typename)
+
+ def cheap_typeid_from_name_nons(self, typename):
+ if typename in self.typeid_cache:
+ return self.typeid_for_string(typename)
+
+ if typename.startswith('QList<') or typename.startswith('QVector<'):
+ typeid = self.typeid_for_string(typename)
+ if typeid:
+ size = 3 * self.ptrSize() if self.qtVersion() >= 0x060000 else self.ptrSize()
+ self.type_code_cache[typeid] = TypeCode.Struct
+ self.type_size_cache[typeid] = size
+ return typeid
+
+ if typename.endswith('*'):
+ inner_typeid = self.cheap_typeid_from_name_nons(typename[0:-1])
+ if inner_typeid != 0:
+ return self.create_pointer_typeid(inner_typeid)
+
+ return 0
+
+ def create_typeid_from_name(self, typename_, size=None):
+ ns = self.qtNamespace()
+ typename = typename_.replace('@', ns)
+
+ if typename in self.typeid_cache:
+ return self.typeid_for_string(typename)
+
+ # This triggers for boost::variant<int, std::string> due to the mis-encoding
+ # of the second template parameter. [MARK_A]
+ knownType = self.lookupType(typename)
+ #self.warn('KNOWN: %s FOR %s' % (knownType, typename))
+ if knownType is not None:
+ #self.warn('USE FROM NATIVE')
+ #self.dump_location()
+ return knownType.typeid
+
+ #self.warn('FAKING: %s SIZE: %s' % (typename, size))
+ typeid = self.typeid_for_string(typename)
+ if size is not None:
+ self.type_size_cache[typeid] = size
+ self.type_code_cache[typeid] = TypeCode.Struct
+ if typename.endswith('*'):
+ self.type_code_cache[typeid] = TypeCode.Pointer
+ self.type_size_cache[typeid] = self.ptrSize()
+ self.type_target_cache[typeid] = self.typeid_for_string(typename[:-1].strip())
+
+ #self.dump_location()
+ #self.warn('CREATED TYPE: %s' % typeid)
+ return typeid
+
+ def createValueFromAddress(self, address, typish):
val = self.Value(self)
- val._type = self.createType(typish)
- #DumperBase.warn('CREATING %s AT 0x%x' % (val.type.name, datish))
+ val.typeid = self.create_typeid(typish)
+ #self.warn('CREATING %s AT 0x%x' % (val.type.name, address))
val.laddress = address
if self.useDynamicType:
- val._type = val.type.dynamicType(address)
+ val.typeid = self.dynamic_typeid_at_address(val.typeid, address)
+ return val
+
+ def createValueFromData(self, data, typish):
+ val = self.Value(self)
+ val.typeid = self.create_typeid(typish)
+ #self.warn('CREATING %s WITH DATA %s' % (val.type.name, self.hexencode(data)))
+ val.ldata = data
+ val.check()
return val
def createValue(self, datish, typish):
- if self.isInt(datish): # Used as address.
- return self.createValueFromAddressAndType(datish, typish)
+ if isinstance(datish, int): # Used as address.
+ return self.createValueFromAddress(datish, typish)
if isinstance(datish, bytes):
- val = self.Value(self)
- val._type = self.createType(typish)
- #DumperBase.warn('CREATING %s WITH DATA %s' % (val.type.name, self.hexencode(datish)))
- val.ldata = datish
- val.check()
- return val
+ return self.createValueFromData(datish, typish)
raise RuntimeError('EXPECTING ADDRESS OR BYTES, GOT %s' % type(datish))
def createProxyValue(self, proxy_data, type_name):
- tdata = self.TypeData(self, type_name)
- tdata.code = TypeCode.Struct
+ typeid = self.typeid_for_string(type_name)
+ self.type_code_cache[typeid] = TypeCode.Struct
val = self.Value(self)
- val._type = self.Type(self, type_name)
+ val.typeid = typeid
val.ldata = proxy_data
return val
@@ -4013,109 +3605,667 @@ class DumperBase():
def __init__(self, dumper):
self.dumper = dumper
self.pattern = ''
- self.currentBitsize = 0
+ self.current_size = 0
self.fields = []
self.autoPadNext = False
self.maxAlign = 1
- def addField(self, fieldSize, fieldCode=None, fieldIsStruct=False,
- fieldName=None, fieldType=None, fieldAlign=1):
+ def add_field(self, field_size, field_code=None, field_is_struct=False,
+ field_name=None, field_typeid=0, field_align=1):
+
+ if field_code is None:
+ field_code = '%ss' % field_size
- if fieldType is not None:
- fieldType = self.dumper.createType(fieldType)
- if fieldSize is None and fieldType is not None:
- fieldSize = fieldType.size()
- if fieldCode is None:
- fieldCode = '%ss' % fieldSize
+ #self.dumper.warn("FIELD SIZE: %s %s %s " % (field_name, field_size, str(field_align)))
if self.autoPadNext:
- self.currentBitsize = 8 * ((self.currentBitsize + 7) >> 3) # Fill up byte.
- padding = (fieldAlign - (self.currentBitsize >> 3)) % fieldAlign
- #DumperBase.warn('AUTO PADDING AT %s BITS BY %s BYTES' % (self.currentBitsize, padding))
- field = self.dumper.Field(self.dumper, bitpos=self.currentBitsize,
+ padding = (field_align - self.current_size) % field_align
+ #self.warn('AUTO PADDING AT %s BITS BY %s BYTES' % (self.current_size, padding))
+ field = self.dumper.Field(self.dumper, bitpos=self.current_size * 8,
bitsize=padding * 8)
self.pattern += '%ds' % padding
- self.currentBitsize += padding * 8
+ self.current_size += padding
self.fields.append(field)
self.autoPadNext = False
- if fieldAlign > self.maxAlign:
- self.maxAlign = fieldAlign
- #DumperBase.warn("MAX ALIGN: %s" % self.maxAlign)
+ if field_align > self.maxAlign:
+ self.maxAlign = field_align
- field = self.dumper.Field(dumper=self.dumper, name=fieldName, type=fieldType,
- isStruct=fieldIsStruct, bitpos=self.currentBitsize,
- bitsize=fieldSize * 8)
+ #self.warn("MAX ALIGN: %s" % self.maxAlign)
- self.pattern += fieldCode
- self.currentBitsize += fieldSize * 8
+ field = self.dumper.Field(name=field_name, typeid=field_typeid,
+ is_struct=field_is_struct, bitpos=self.current_size *8,
+ bitsize=field_size * 8)
+
+ self.pattern += field_code
+ self.current_size += field_size
self.fields.append(field)
+ def describe_struct_member(self, typename):
+ typename = typename.replace('@', self.qtNamespace())
+
+ typeid = self.cheap_typeid_from_name_nons(typename)
+ if typeid:
+ size = self.type_size_cache.get(typeid, None)
+ if size is not None:
+ return size, typeid
+
+ typeobj = self.lookupType(typename)
+ self.warn("LOOKUP FIELD TYPE: %s TYPEOBJ: %s" % (typename, typeobj))
+ if typeobj is not None:
+ typeid = typeobj.typeid
+ size = self.type_size_cache.get(typeid, None)
+ if size is not None:
+ return size, typeid
+
+ self.warn("UNKNOWN EMBEDDED TYPE: %s" % typename)
+ return 0, 0
+
+ @functools.lru_cache(maxsize = None)
def describeStruct(self, pattern):
- if pattern in self.structPatternCache:
- return self.structPatternCache[pattern]
ptrSize = self.ptrSize()
builder = self.StructBuilder(self)
n = None
- typeName = ''
+ typename = ''
readingTypeName = False
+ #self.warn("PATTERN: %s" % pattern)
for c in pattern:
+ #self.warn("PAT CODE: %s %s" % (c, str(n)))
if readingTypeName:
if c == '}':
readingTypeName = False
- fieldType = self.createType(typeName)
- fieldAlign = fieldType.alignment()
- builder.addField(n, fieldIsStruct=True,
- fieldType=fieldType, fieldAlign=fieldAlign)
- typeName = None
+ n, field_typeid = self.describe_struct_member(typename)
+
+ field_align = self.type_alignment(field_typeid)
+ builder.add_field(n,
+ field_is_struct=True,
+ field_typeid=field_typeid,
+ field_align=field_align)
+ typename = None
n = None
else:
- typeName += c
+ typename += c
elif c == 't': # size_t
- builder.addField(ptrSize, self.ptrCode(), fieldAlign=ptrSize)
+ builder.add_field(ptrSize, self.ptrCode(), field_align=ptrSize)
elif c == 'p': # Pointer as int
- builder.addField(ptrSize, self.ptrCode(), fieldAlign=ptrSize)
+ builder.add_field(ptrSize, self.ptrCode(), field_align=ptrSize)
elif c == 'P': # Pointer as Value
- builder.addField(ptrSize, '%ss' % ptrSize, fieldAlign=ptrSize)
+ builder.add_field(ptrSize, '%ss' % ptrSize, field_align=ptrSize)
elif c in ('d'):
- builder.addField(8, c, fieldAlign=ptrSize) # fieldType = 'double' ?
+ builder.add_field(8, c, field_align=ptrSize) # field_type = 'double' ?
elif c in ('q', 'Q'):
- builder.addField(8, c, fieldAlign=ptrSize)
+ builder.add_field(8, c, field_align=ptrSize)
elif c in ('i', 'I', 'f'):
- builder.addField(4, c, fieldAlign=4)
+ builder.add_field(4, c, field_align=4)
elif c in ('h', 'H'):
- builder.addField(2, c, fieldAlign=2)
+ builder.add_field(2, c, field_align=2)
elif c in ('b', 'B', 'c'):
- builder.addField(1, c, fieldAlign=1)
+ builder.add_field(1, c, field_align=1)
elif c >= '0' and c <= '9':
if n is None:
n = ''
n += c
elif c == 's':
- builder.addField(int(n), fieldAlign=1)
+ builder.add_field(int(n), field_align=1)
n = None
elif c == '{':
readingTypeName = True
- typeName = ''
+ typename = ''
elif c == '@':
if n is None:
# Automatic padding depending on next item
builder.autoPadNext = True
else:
# Explicit padding.
- builder.currentBitsize = 8 * ((builder.currentBitsize + 7) >> 3)
- padding = (int(n) - (builder.currentBitsize >> 3)) % int(n)
+ padding = (int(n) - builder.current_size) % int(n)
field = self.Field(self)
builder.pattern += '%ds' % padding
- builder.currentBitsize += padding * 8
+ builder.current_size += padding
builder.fields.append(field)
n = None
else:
raise RuntimeError('UNKNOWN STRUCT CODE: %s' % c)
pp = builder.pattern
- size = (builder.currentBitsize + 7) >> 3
+ size = builder.current_size
fields = builder.fields
tailPad = (builder.maxAlign - size) % builder.maxAlign
size += tailPad
- self.structPatternCache[pattern] = (pp, size, fields)
+ #self.warn("FIELDS: %s" % ((pp, size, fields),))
return (pp, size, fields)
+
+ def type_stringify(self, typeid):
+ return 'Type(id="%s",name="%s",bsize=%s,code=%s)'% (
+ str(typeid),
+ self.type_name_cache.get(typeid, '?'),
+ self.type_bitsize_cache.get(typeid, '?'),
+ self.type_code_cache.get(typeid, '?'))
+
+ def type_name(self, typeid):
+ name = self.type_name_cache.get(typeid, None)
+ if name is None:
+ self.dump_type_cache()
+ self.check_typeid(typeid)
+ raise RuntimeError('UNNAMED TYPE: %d' % typeid)
+ return name
+
+ def type_code(self, typeid):
+ # This does not seem to be needed for GDB and LLDB
+ if not typeid in self.type_code_cache:
+ typename = self.type_name_cache.get(typeid, None)
+ if typename is None:
+ raise RuntimeError('NAME/ID ERROR FOR %s' % typeid)
+ #self.warn("EMERGENCY LOOKUP: %s " % typename)
+ typeobj = self.lookupType(typename)
+ if typeobj is None:
+ #self.warn("EMERGENCY LOOKUP FAILED: %s " % typeid)
+ #self.dump_type_cache()
+ return TypeCode.Struct
+ #self.warn("EMERGENCY LOOKUP SUCCEEDED: %s " % typeid)
+ typeid = typeobj.typeid
+ return self.type_code_cache[typeid]
+
+ def type_bitpos(self, typeid):
+ return self.type_bitpos_cache[typeid]
+
+ def type_target(self, typeid):
+ return self.type_target_cache.get(typeid, None)
+ targetid = self.type_target_cache.get(typeid, None)
+ if not targetid in self.type_code_cache:
+ typename = self.type_name_cache.get(targetid, None)
+ if typename is None:
+ raise RuntimeError('NAME/ID ERROR FOR TARGET %s' % targetid)
+ typeobj = self.lookupType(typename)
+ if typeobj is None:
+ #self.warn("EMERGENCY LOOKUP FAILED FOR %s %s " % (typename, typeid))
+ #self.dump_type_cache()
+ return 0 # Void type id
+ return targetid
+
+ def type_template_arguments(self, typeid):
+ targs = []
+ #self.dump_type_cache()
+ #self.warn('TRY TEMPLATE ARGS FOR %s' % typeid)
+ for index in range(0, 100):
+ targ = self.type_template_argument(typeid, index)
+ #self.warn('INDEX %s %s' % (index, targ))
+ if targ is None:
+ break
+ targs.append(targ)
+ #self.warn('TARGS %s' % targs)
+ return targs
+
+ def nativeTemplateParameter(self, typeid, index, nativeType):
+ return None
+
+ def type_template_argument(self, typeid, index):
+ targ = self.type_template_arguments_cache.get((typeid, index), None)
+ if targ is not None:
+ return targ
+
+ native_type = self.type_nativetype_cache.get(typeid, None)
+ if native_type is not None:
+ targ = self.nativeTemplateParameter(typeid, index, native_type)
+ if targ is not None:
+ self.type_template_arguments_cache[(typeid, index)] = targ
+ return targ
+
+ # FIXME: The block below is apparently not needed anymore in the GDB
+ # and LLDB cases, so removing also doesn't bring performance. But it
+ # is at least potentially one source of type lookups.
+ #typename = self.type_name(typeid)
+ #self.dump_type_cache()
+ #self.warn('TEMPLATE ARGS FOR %s %s' % (typeid, typename))
+ #typeobj = self.lookupType(typename)
+ #if typeobj is not None:
+ # #self.warn(' FOUNT NATIVE %s %s, %s' % (typeid, typeobj, native_type))
+ # native_type = self.type_nativetype_cache.get(typeobj.typeid, None)
+ # #targ = self.type_template_argument(typeobj.typeid, index)
+ # targ = self.nativeTemplateParameter(typeobj.typeid, index, native_type)
+ # if targ is not None:
+ # self.type_template_arguments_cache[(typeid, index)] = targ
+ # return targ
+
+ # Native lookups didn't help. Happens for 'wrong' placement of 'const'
+ # etc. with LLDB or template parameter packs with gcc in boost::variant
+ # 13.2.0. But not all is lost:
+ self.fill_template_parameters_manually(typeid)
+ targ = self.type_template_arguments_cache.get((typeid, index), None)
+ return targ
+
+ def type_alignment(self, typeid):
+ alignment = self.type_alignment_cache.get(typeid, None)
+ if alignment is not None:
+ return alignment
+
+ code = self.type_code_cache.get(typeid, None)
+ if code in (TypeCode.Typedef, TypeCode.Array):
+ alignment = self.type_alignment(self.type_target_cache[typeid])
+ elif code in (TypeCode.Integral, TypeCode.Float, TypeCode.Enum):
+ name = self.type_name(typeid)
+ if name in ('double', 'long long', 'unsigned long long'):
+ # Crude approximation.
+ alignment = 8 if self.isWindowsTarget() else self.ptrSize()
+ else:
+ alignment = self.type_size(typeid)
+ elif code in (TypeCode.Pointer, TypeCode.Reference, TypeCode.RValueReference):
+ alignment = self.ptrSize()
+ elif self.isCdb:
+ alignment = self.nativeStructAlignment(self.type_nativetype(typeid))
+ else:
+ size = self.type_size(typeid)
+ if size is None:
+ self.dump_type_cache()
+ self.warn("NO ALIGNMENT FOUND FOR SIZE OF TYPE %s" % str(typeid))
+ return 1
+ if size >= self.ptrSize():
+ alignment = self.ptrSize()
+ else:
+ alignment = size
+ #self.warn("GUESSING ALIGNMENT %s FOR TYPEID %s" % (alignment, typeid))
+ self.type_alignment_cache[typeid] = alignment
+ return alignment
+
+
+ def type_nativetype(self, typeid):
+ native_type = self.type_nativetype_cache.get(typeid, None)
+ if native_type is not None:
+ return native_type
+
+ typename = self.type_name(typeid)
+ native_type = self.lookupNativeType(typename)
+ # Also cache unsuccessful attempts
+ self.type_nativetype_cache[typeid] = native_type
+
+ return native_type
+
+
+ def type_size(self, typeid):
+ self.check_typeid(typeid)
+ size = self.type_size_cache.get(typeid, None)
+ if size is not None:
+ return size
+
+ if size is None:
+ nativeType = self.type_nativetype(typeid)
+ if not self.type_size_cache.get(typeid):
+ self.from_native_type(nativeType)
+ size = self.type_size_cache.get(typeid, None)
+
+ if size is not None:
+ self.type_size_cache[typeid] = size
+ else:
+ self.dump_type_cache()
+ self.warn("CANNOT DETERMINE SIZE FOR TYPE %s" % str(typeid))
+
+ return size
+
+ def type_bitsize(self, typeid):
+ bitsize = self.type_bitsize_cache.get(typeid, None)
+ if bitsize is None:
+ bitsize = 8 * self.type_size(typeid)
+ self.type_bitsize_cache[typeid] = bitsize
+ return bitsize
+
+ def dynamic_typeid_at_address(self, base_typeid, address):
+ #with self.dumper.timer('dynamic_typeid_at_address %s 0x%s' % (self.name, address)):
+ type_code = self.type_code_cache.get(base_typeid, None)
+ if type_code != TypeCode.Struct:
+ #self.dump_type_cache()
+ #self.warn('SHORT CUT FOR BASE ID: %d TC: %s' % (base_typeid, type_code))
+ return base_typeid
+
+ # This turned out to be expensive.
+ #try:
+ # vtbl = self.extract_pointer_at_address(address)
+ #except:
+ # return base_typeid
+ ##self.warn('VTBL: 0x%x' % vtbl)
+ #if not self.couldBePointer(vtbl):
+ # return base_typeid
+ #self.warn("DYN TYPE FOR %s %s" % (base_typeid, self.type_name(base_typeid)))
+
+ return self.nativeDynamicType(address, base_typeid)
+
+ # This is the generic version for synthetic values.
+ # The native backends replace it in their fromNativeValue()
+ # implementations.
+ def value_members(self, value, include_bases):
+ #self.warn("LISTING MEMBERS OF %s" % value)
+ #self.warn("LISTING MEMBERS OF TYPE %s %s" % (value.typeid, self.type_name(value.typeid)))
+ typeid = value.typeid
+
+ members = self.type_fields_cache.get(typeid, None)
+ if members is not None:
+ return members
+
+ members = []
+ native_type = self.type_nativetype_cache.get(typeid, None)
+ if native_type is None:
+ native_type = self.lookupNativeType(self.type_name(typeid))
+ if not native_type is None:
+ members = self.nativeListMembers(value, native_type, include_bases)
+ #self.warn("FIELDS 2: %s" % ', '.join(str(f) for f in members))
+ else:
+ self.warn("NO NATIVE TYPE FIELDS FOR: %s" % typeid)
+
+ #self.warn("GOT MEMBERS: %s" % ', '.join(str(f.name) for f in members))
+ return members
+
+ def value_member_by_field(self, value, field):
+ #self.warn("EXTRACTING MEMBER '%s' OF %s AT OFFSET %s" % (field.name, field.typeid, field.bitpos))
+ val = self.Value(self)
+ val.typeid = field.typeid
+ val.name = field.name
+ val.isBaseClass = field.is_base_class
+ #self.warn('CREATING %s WITH DATA %s' % (val.type.name, self.hexencode(data)))
+ field_offset = field.bitpos // 8
+ if value.laddress is not None:
+ val.laddress = value.laddress + field_offset
+ field_size = (field.bitsize + 7) // 8
+ blob = self.value_data(value, field_offset + field_size)
+ val.ldata = blob[field_offset:field_offset + field_size]
+ #self.dump_location()
+ return val
+
+ def value_member_by_name(self, value, name):
+ #field = self.type_fields_cache.get((value.typeid, name), None)
+ #if field is not None:
+ # return self.value_member_by_field(value, field)
+
+ #self.dump_location()
+ #self.warn("WANT MEMBER '%s' OF '%s'" % (name, value))
+ #value.check()
+ value_typecode = self.type_code(value.typeid)
+ if value_typecode == TypeCode.Typedef:
+ return self.value_member_by_name(self.value_detypedef(value), name)
+ if value_typecode in (TypeCode.Pointer, TypeCode.Reference, TypeCode.RValueReference):
+ res = self.value_member_by_name(self.value_dereference(value), name)
+ if res is not None:
+ return res
+ if value_typecode == TypeCode.Struct:
+ #self.warn('SEARCHING FOR MEMBER: %s IN %s' % (name, value.type.name))
+ members = self.value_members(value, True)
+ #self.warn('MEMBERS: %s' % ', '.join(str(m.name) for m in members))
+ base = None
+ for member in members:
+ #self.warn('CHECKING FIELD %s' % member.name)
+ if member.type.code == TypeCode.Typedef:
+ member = member.detypedef()
+ if member.name == name:
+ #self.warn('FOUND MEMBER 1: %s IN %s' % (name, value.type.name))
+ return member
+ if member.isBaseClass:
+ base = member
+ if self.isCdb:
+ if base is not None:
+ # self.warn("CHECKING BASE CLASS '%s' for '%s'" % (base.type.name, name))
+ res = self.value_member_by_name(base, name)
+ if res is not None:
+ # self.warn('FOUND MEMBER 2: %s IN %s' % (name, value.type.name))
+ return res
+ else:
+ for member in members:
+ if member.type.code == TypeCode.Typedef:
+ member = member.detypedef()
+ if member.name == name: # Could be base class.
+ return member
+ if member.type.code == TypeCode.Struct:
+ res = self.value_member_by_name(member, name)
+ if res is not None:
+ #self.warn('FOUND MEMBER 2: %s IN %s' % (name, value.type.name))
+ return res
+
+ #self.warn('DID NOT FIND MEMBER: %s IN %s' % (name, value.type.name))
+ #self.dump_location()
+ return None
+
+ def value_member_by_indexish(self, value, indexish):
+ #self.warn('GET ITEM %s %s' % (self, indexish))
+ #value.check()
+ value_typecode = self.type_code(value.typeid)
+ if isinstance(indexish, str):
+ if value_typecode == TypeCode.Pointer:
+ #self.warn('GET ITEM %s DEREFERENCE TO %s' % (value, value.dereference()))
+ return value.dereference().__getitem__(indexish)
+ res = self.value_member_by_name(value, indexish)
+ if res is None:
+ raise RuntimeError('No member named %s in type %s'
+ % (indexish, value.type.name))
+ return res
+ if isinstance(indexish, int):
+ if value_typecode == TypeCode.Array:
+ addr = value.laddress + int(indexish) * value.type.target().size()
+ return self.createValueFromAddress(addr, value.type.target())
+ if value_typecode == TypeCode.Pointer:
+ addr = value.pointer() + int(indexish) * value.type.target().size()
+ return self.createValueFromAddress(addr, value.type.target())
+ return self.value_members(value, False)[indexish]
+ raise RuntimeError('BAD INDEX TYPE %s' % type(indexish))
+
+ def value_extract_bits(self, value, bitpos, bitsize):
+ value_size = self.type_size(value.typeid)
+ ldata = bytes(self.value_data(value, value_size))
+ bdata = ''.join([format(x, '0>8b')[::-1] for x in ldata])
+ fdata = bdata[bitpos : bitpos + bitsize]
+ fdata = fdata[::-1]
+ return int(fdata, 2)
+
+ def value_display_enum(self, value, form='%d', bitsize=None):
+ size = value.type.size()
+ intval = self.value_extract_integer(value, size, False)
+ dd = self.type_enum_display_cache.get(value.typeid, None)
+ if dd is None:
+ return str(intval)
+ return dd(intval, value.laddress, form)
+
+ def value_as_address(self, value):
+ return self.value_extract_integer(value, self.ptrSize(), False)
+
+ def value_as_integer(self, value):
+ if isinstance(value.ldata, int):
+ return value.ldata
+ type_name = self.type_name(value.typeid)
+ signed = type_name != 'unsigned' \
+ and not type_name.startswith('unsigned ') \
+ and type_name.find(' unsigned ') == -1
+ size = value.type.size()
+ return self.value_extract_integer(value, size, signed)
+
+ def value_as_floating_point(self, value):
+ if value.nativeValue is not None and not self.isCdb:
+ return str(value.nativeValue)
+ if self.type_code(value.typeid) == TypeCode.Typedef:
+ return self.value_as_floating_point(self.value_detypedef(value))
+ if value.type.size() == 8:
+ blob = self.value_data(value, 8)
+ return struct.unpack_from(self.packCode + 'd', blob, 0)[0]
+ if value.type.size() == 4:
+ blob = self.value_data(value, 4)
+ return struct.unpack_from(self.packCode + 'f', blob, 0)[0]
+ # Fall back in case we don't have a nativeValue at hand.
+ # FIXME: This assumes Intel's 80bit extended floats. Which might
+ # be wrong.
+ l, h = value.split('QQ')
+ if True: # 80 bit floats
+ sign = (h >> 15) & 1
+ exp = (h & 0x7fff)
+ fraction = l
+ bit63 = (l >> 63) & 1
+ #self.warn("SIGN: %s EXP: %s H: 0x%x L: 0x%x" % (sign, exp, h, l))
+ if exp == 0:
+ if bit63 == 0:
+ if l == 0:
+ res = '-0' if sign else '0'
+ else:
+ res = (-1)**sign * l * 2**(-16382) # subnormal
+ else:
+ res = 'pseudodenormal'
+ elif exp == 0x7fff:
+ res = 'special'
+ else:
+ res = (-1)**sign * l * 2**(exp - 16383 - 63)
+ else: # 128 bits
+ sign = h >> 63
+ exp = (h >> 48) & 0x7fff
+ fraction = h & (2**48 - 1)
+ #self.warn("SIGN: %s EXP: %s FRAC: %s H: 0x%x L: 0x%x" % (sign, exp, fraction, h, l))
+ if exp == 0:
+ if fraction == 0:
+ res = -0.0 if sign else 0.0
+ else:
+ res = (-1)**sign * fraction / 2**48 * 2**(-62) # subnormal
+ elif exp == 0x7fff:
+ res = ('-inf' if sign else 'inf') if fraction == 0 else 'nan'
+ else:
+ res = (-1)**sign * (1 + fraction / 2**48) * 2**(exp - 63)
+ return res
+
+ def value_data(self, value, size):
+ if value.ldata is not None:
+ return value.ldata[:size]
+ if value.laddress is not None:
+ return self.value_data_from_address(value.laddress, size)
+ raise RuntimeError('CANNOT CONVERT TO BYTES: %s' % value)
+
+ def value_data_from_address(self, address, size):
+ if not isinstance(address, int):
+ raise RuntimeError('ADDRESS WRONG TYPE: %s' % type(address))
+ if not isinstance(size, int):
+ raise RuntimeError('SIZE WRONG TYPE: %s' % type(size))
+ if size <= 0:
+ raise RuntimeError('SIZE WRONG VALUE: %s' % size)
+ res = self.readRawMemory(address, size)
+ if len(res) > 0:
+ return res
+ raise RuntimeError('CANNOT READ %d BYTES FROM ADDRESS: %s %s' % (size, address))
+
+ def value_display(self, value):
+ type_code = self.type_code(value.typeid)
+ if type_code == TypeCode.Enum:
+ return self.value_display_enum(value)
+ if type_code == TypeCode.Typedef:
+ return self.value_display(self.value_detypedef(value))
+ if type_code == TypeCode.Integral:
+ return self.value_as_integer(value)
+ if type_code == TypeCode.Bitfield:
+ return self.value_as_integer(value)
+ if type_code == TypeCode.Float:
+ return self.value_as_floating_point(value)
+ if type_code == TypeCode.Pointer:
+ return self.value_as_address(value)
+ return None
+
+ def value_detypedef(self, value):
+ #value.check()
+ #if value.type.code != TypeCode.Typedef:
+ # raise RuntimeError("WRONG")
+ val = value.copy()
+ val.typeid = self.type_target(value.typeid)
+ #self.warn("DETYPEDEF FROM: %s" % self)
+ #self.warn("DETYPEDEF TO: %s" % val)
+ return val
+
+ def split(self, pattern, value_or_address):
+ if isinstance(value_or_address, self.Value):
+ return self.value_split(value_or_address, pattern)
+ if isinstance(value_or_address, int):
+ val = self.Value(self)
+ val.laddress = value_or_address
+ return self.value_split(val, pattern)
+ raise RuntimeError('CANNOT EXTRACT STRUCT FROM %s' % type(value_or_address))
+
+ def value_split(self, value, pattern):
+ #self.warn('EXTRACT STRUCT FROM: %s' % self.type)
+ (pp, size, fields) = self.describeStruct(pattern)
+ #self.warn('SIZE: %s ' % size)
+
+ blob = self.value_data(value, size)
+ address = value.laddress
+
+ parts = struct.unpack_from(self.packCode + pp, blob)
+
+ def fix_struct(field, part):
+ #self.warn('STRUCT MEMBER: %s' % type(part))
+ if field.is_struct:
+ res = self.Value(self)
+ res.typeid = field.typeid
+ res.ldata = part
+ if address is not None:
+ res.laddress = address + field.bitpos // 8
+ return res
+ return part
+
+ if len(fields) != len(parts):
+ raise RuntimeError('STRUCT ERROR: %s %s' % (fields, parts))
+ return tuple(map(fix_struct, fields, parts))
+
+ def type_dereference(self, typeid):
+ if self.type_code(typeid) == TypeCode.Typedef:
+ return self.type_dereference(self.type_target(typeid))
+ return self.type_target(typeid)
+
+ def type_strip_typedefs(self, typeid):
+ if self.type_code(typeid) == TypeCode.Typedef:
+ return self.type_strip_typedefs(self.type_target(typeid))
+ return typeid
+
+ def value_dereference(self, value):
+ value.check()
+ #if value.type.code == TypeCode.Typedef:
+ # return self.value_dereference(self.value_detypedef(value))
+ val = self.Value(self)
+ if value.type.code in (TypeCode.Reference, TypeCode.RValueReference):
+ val.summary = value.summary
+ if value.nativeValue is None:
+ val.laddress = value.pointer()
+ if val.laddress is None and value.laddress is not None:
+ val.laddress = value.laddress
+ val.typeid = self.type_dereference(value.typeid)
+ if self.useDynamicType:
+ val.typeid = self.nativeDynamicType(val.laddress, val.typeid)
+ else:
+ val = self.nativeValueDereferenceReference(value)
+ elif value.type.code == TypeCode.Pointer:
+ try:
+ val = self.nativeValueDereferencePointer(value)
+ except:
+ val.laddress = value.pointer()
+ val.typeid = self.type_dereference(value.typeid)
+ if self.useDynamicType:
+ val.typeid = self.nativeDynamicType(val.laddress, val.typeid)
+ else:
+ raise RuntimeError("WRONG: %s" % value.type.code)
+
+ return val
+
+ def value_cast(self, value, typish):
+ value.check()
+ val = self.Value(self)
+ val.laddress = value.laddress
+ val.ldata = value.ldata
+ val.typeid = self.create_typeid(typish)
+ return val
+
+ def value_plus_something(self, value, other):
+ value.check()
+ if isinstance(other, int):
+ stripped = self.type_strip_typedefs(value.typeid)
+ if self.type_code(stripped) == TypeCode.Pointer:
+ item_size = self.type_size(self.type_dereference(stripped))
+ address = self.value_as_address(value) + item_size * other
+ val = self.Value(self)
+ val.laddress = None
+ val.ldata = address
+ val.typeid = value.typeid
+ return val
+ raise RuntimeError('BAD DATA TO ADD TO: %s %s' % (value.type, other))
+
+ def value_minus_something(self, value, other):
+ value.check()
+ if other.type.name == value.type.name:
+ stripped = self.type_strip_typedefs(value.typeid)
+ if self.type_code(stripped.code) == TypeCode.Pointer:
+ item_size = self.type_size(self.type_dereference(stripped))
+ return (value.pointer() - other.pointer()) // item_size
+ raise RuntimeError('BAD DATA TO SUB TO: %s %s' % (value.type, other))
+
diff --git a/share/qtcreator/debugger/gdbbridge.py b/share/qtcreator/debugger/gdbbridge.py
index 9699e518fe..f30b0fbafa 100644
--- a/share/qtcreator/debugger/gdbbridge.py
+++ b/share/qtcreator/debugger/gdbbridge.py
@@ -10,11 +10,10 @@ import gdb
import os
import os.path
import re
-import sys
import struct
import tempfile
-from dumper import DumperBase, Children, toInteger, TopLevelItem
+from dumper import DumperBase, Children, TopLevelItem
from utils import TypeCode
from gdbtracepoint import *
@@ -119,7 +118,6 @@ ScanStackCommand()
class PlainDumper():
def __init__(self, printer):
self.printer = printer
- self.typeCache = {}
def __call__(self, d, value):
if value.nativeValue is None:
@@ -137,8 +135,6 @@ class PlainDumper():
if isinstance(val, str):
# encode and avoid extra quotes ('"') at beginning and end
d.putValue(d.hexencode(val), 'utf8:1:0')
- elif sys.version_info[0] <= 2 and isinstance(val, unicode):
- d.putValue(val)
elif val is not None: # Assuming LazyString
d.putCharArrayValue(val.address, val.length,
val.type.target().sizeof)
@@ -166,7 +162,7 @@ def importPlainDumpers(args):
gdb.execute('disable pretty-printer .* .*')
except:
# Might occur in non-ASCII directories
- DumperBase.warn('COULD NOT DISABLE PRETTY PRINTERS')
+ theDumper.warn('COULD NOT DISABLE PRETTY PRINTERS')
else:
theDumper.usePlainDumpers = True
theDumper.importPlainDumpers()
@@ -192,15 +188,17 @@ class Dumper(DumperBase):
# These values will be kept between calls to 'fetchVariables'.
self.isGdb = True
- self.typeCache = {}
self.interpreterBreakpointResolvers = []
+ def warn(self, message):
+ print('bridgemessage={msg="%s"},' % message.replace('"', '$').encode('latin1'))
+
def prepare(self, args):
self.output = []
self.setVariableFetchingOptions(args)
def fromFrameValue(self, nativeValue):
- #DumperBase.warn('FROM FRAME VALUE: %s' % nativeValue.address)
+ #self.warn('FROM FRAME VALUE: %s' % nativeValue.address)
val = nativeValue
if self.useDynamicType:
try:
@@ -209,71 +207,43 @@ class Dumper(DumperBase):
pass
return self.fromNativeValue(val)
- def nativeValueType(self, nativeValue):
- return self.fromNativeType(nativeValue.type)
-
def fromNativeValue(self, nativeValue):
- #DumperBase.warn('FROM NATIVE VALUE: %s' % nativeValue)
+ #self.warn('FROM NATIVE VALUE: %s' % nativeValue)
self.check(isinstance(nativeValue, gdb.Value))
nativeType = nativeValue.type
code = nativeType.code
+
+ val = self.Value(self)
+ val.nativeValue = nativeValue
+
if code == gdb.TYPE_CODE_REF:
- targetType = self.fromNativeType(nativeType.target().unqualified())
- val = self.createReferenceValue(toInteger(nativeValue.address), targetType)
- val.nativeValue = nativeValue
- #DumperBase.warn('CREATED REF: %s' % val)
+ target_typeid = self.from_native_type(nativeType.target().unqualified())
+ val.ldata = int(nativeValue.address)
+ if self.useDynamicType: # needed for Gdb13393
+ target_typeid = self.dynamic_typeid_at_address(target_typeid, val.ldata)
+ val.typeid = self.create_reference_typeid(target_typeid)
+ #self.warn('CREATED REF: %s' % val)
return val
+
if code == gdb.TYPE_CODE_PTR:
- try:
- nativeTargetValue = nativeValue.dereference()
- except:
- nativeTargetValue = None
- targetType = self.fromNativeType(nativeType.target().unqualified())
- val = self.createPointerValue(toInteger(nativeValue), targetType)
- # The nativeValue is needed in case of multiple inheritance, see
- # QTCREATORBUG-17823. Using it triggers nativeValueDereferencePointer()
- # later which
- # is surprisingly expensive.
- val.nativeValue = nativeValue
- #DumperBase.warn('CREATED PTR 1: %s' % val)
+ target_typeid = self.from_native_type(nativeType.target().unqualified())
+ val.ldata = int(nativeValue)
+ val.typeid = self.create_pointer_typeid(target_typeid)
+ #self.warn('CREATED PTR 1: %s' % val)
if nativeValue.address is not None:
- val.laddress = toInteger(nativeValue.address)
- #DumperBase.warn('CREATED PTR 2: %s' % val)
+ val.laddress = int(nativeValue.address)
+ #self.warn('CREATED PTR 2: %s' % val)
return val
- if code == gdb.TYPE_CODE_TYPEDEF:
- targetType = nativeType.strip_typedefs().unqualified()
- #DumperBase.warn('TARGET TYPE: %s' % targetType)
- if targetType.code == gdb.TYPE_CODE_ARRAY:
- val = self.Value(self)
- else:
- try:
- # Cast may fail for arrays, for typedefs to __uint128_t with
- # gdb.error: That operation is not available on integers
- # of more than 8 bytes.
- # See test for Bug5799, QTCREATORBUG-18450.
- val = self.fromNativeValue(nativeValue.cast(targetType))
- except:
- val = self.Value(self)
- #DumperBase.warn('CREATED TYPEDEF: %s' % val)
- else:
- val = self.Value(self)
- val.nativeValue = nativeValue
if nativeValue.address is not None:
- val.laddress = toInteger(nativeValue.address)
- else:
- size = nativeType.sizeof
- chars = self.lookupNativeType('unsigned char')
- y = nativeValue.cast(chars.array(0, int(nativeType.sizeof - 1)))
- buf = bytearray(struct.pack('x' * size))
- for i in range(size):
- try:
- buf[i] = int(y[i])
- except:
- pass
- val.ldata = bytes(buf)
+ val.laddress = int(nativeValue.address)
+ elif code == gdb.TYPE_CODE_STRUCT:
+ try:
+ val.ldata = nativeValue.bytes # GDB 15 only
+ except:
+ val.ldata = self.nativeDataFromValueFallback(nativeValue, nativeValue.type.sizeof)
- val._type = self.fromNativeType(nativeType)
+ val.typeid = self.from_native_type(nativeType)
val.lIsInScope = not nativeValue.is_optimized_out
code = nativeType.code
if code == gdb.TYPE_CODE_ENUM:
@@ -283,10 +253,15 @@ class Dumper(DumperBase):
val.ldisplay += ' (%s)' % intval
elif code == gdb.TYPE_CODE_COMPLEX:
val.ldisplay = str(nativeValue)
- elif code in [gdb.TYPE_CODE_BOOL, gdb.TYPE_CODE_INT]:
+ elif code == gdb.TYPE_CODE_BOOL:
+ # FIXME: why?
+ # Using ldata breaks StdVariant test, not setting lvalue breaks the Bitfield[s2] test.
+ val.lvalue = int(nativeValue)
+ val.ldata = None
+ elif code == gdb.TYPE_CODE_INT:
try:
# extract int presentation from native value and remember it
- val.lvalue = int(nativeValue)
+ val.ldata = int(nativeValue)
except:
# GDB only support converting integers of max. 64 bits to Python int as of now
pass
@@ -294,65 +269,81 @@ class Dumper(DumperBase):
# val.type.ltarget = nativeValue[0].type.unqualified()
return val
+ def nativeDataFromValueFallback(self, nativeValue, size):
+ chars = self.lookupNativeType('unsigned char')
+ try:
+ y = nativeValue.cast(chars.array(0, int(size - 1)))
+ buf = bytearray(struct.pack('x' * size))
+ for i in range(size):
+ try:
+ buf[i] = int(y[i])
+ except:
+ pass
+ return bytes(buf)
+ except:
+ self.warn('VALUE EXTRACTION FAILED: VALUE: %s SIZE: %s' % (nativeValue, size))
+ return None
+
def ptrSize(self):
result = gdb.lookup_type('void').pointer().sizeof
self.ptrSize = lambda: result
return result
- def fromNativeType(self, nativeType):
+ def from_native_type(self, nativeType):
self.check(isinstance(nativeType, gdb.Type))
- code = nativeType.code
- #DumperBase.warn('FROM NATIVE TYPE: %s' % nativeType)
+
+ #self.warn('FROM NATIVE TYPE: %s' % nativeType)
nativeType = nativeType.unqualified()
- if code == gdb.TYPE_CODE_PTR:
- #DumperBase.warn('PTR')
- targetType = self.fromNativeType(nativeType.target().unqualified())
- return self.createPointerType(targetType)
+ typeid_str = self.native_type_key(nativeType)
+ known_typeid = self.typeid_from_typekey.get(typeid_str, None)
+ if known_typeid is not None:
+ return known_typeid
- if code == gdb.TYPE_CODE_REF:
- #DumperBase.warn('REF')
- targetType = self.fromNativeType(nativeType.target().unqualified())
- return self.createReferenceType(targetType)
-
- if hasattr(gdb, "TYPE_CODE_RVALUE_REF"):
- if code == gdb.TYPE_CODE_RVALUE_REF:
- #DumperBase.warn('RVALUEREF')
- targetType = self.fromNativeType(nativeType.target())
- return self.createRValueReferenceType(targetType)
-
- if code == gdb.TYPE_CODE_ARRAY:
- #DumperBase.warn('ARRAY')
+ code = nativeType.code
+
+ if code == gdb.TYPE_CODE_PTR:
+ #self.warn('PTR')
+ target_typeid = self.from_native_type(nativeType.target().unqualified())
+ typeid = self.create_pointer_typeid(target_typeid)
+
+ elif code == gdb.TYPE_CODE_REF:
+ #self.warn('REF')
+ target_typeid = self.from_native_type(nativeType.target().unqualified())
+ typeid = self.create_reference_typeid(target_typeid)
+
+ elif code == gdb.TYPE_CODE_RVALUE_REF and hasattr(gdb, "TYPE_CODE_RVALUE_REF"):
+ #self.warn('RVALUEREF')
+ target_typeid = self.from_native_type(nativeType.target())
+ typeid = self.create_rvalue_reference_typeid(target_typeid)
+
+ elif code == gdb.TYPE_CODE_ARRAY:
+ #self.warn('ARRAY')
nativeTargetType = nativeType.target().unqualified()
- targetType = self.fromNativeType(nativeTargetType)
+ target_typeid = self.from_native_type(nativeTargetType)
if nativeType.sizeof == 0:
# QTCREATORBUG-23998, note that nativeType.name == None here,
# whereas str(nativeType) returns sth like 'QObject [5]'
count = self.arrayItemCountFromTypeName(str(nativeType), 1)
else:
count = nativeType.sizeof // nativeTargetType.sizeof
- return self.createArrayType(targetType, count)
+ typeid = self.create_array_typeid(target_typeid, count)
- if code == gdb.TYPE_CODE_TYPEDEF:
- #DumperBase.warn('TYPEDEF')
+ elif code == gdb.TYPE_CODE_TYPEDEF:
+ #self.warn('TYPEDEF')
nativeTargetType = nativeType.unqualified()
while nativeTargetType.code == gdb.TYPE_CODE_TYPEDEF:
nativeTargetType = nativeTargetType.strip_typedefs().unqualified()
- targetType = self.fromNativeType(nativeTargetType)
- return self.createTypedefedType(targetType, str(nativeType),
- self.nativeTypeId(nativeType))
+ target_typeid = self.from_native_type(nativeTargetType)
+ typeid = self.create_typedefed_typeid(target_typeid, str(nativeType), typeid_str)
- if code == gdb.TYPE_CODE_ERROR:
+ elif code == gdb.TYPE_CODE_ERROR:
self.warn('Type error: %s' % nativeType)
- return self.Type(self, '')
-
- typeId = self.nativeTypeId(nativeType)
- res = self.typeData.get(typeId, None)
- if res is None:
- tdata = self.TypeData(self, typeId)
- tdata.name = str(nativeType)
- tdata.lbitsize = nativeType.sizeof * 8
- tdata.code = {
+ typeid = 0 # the invalid id
+
+ else:
+ typeid = self.typeid_for_string(typeid_str)
+ type_code = {
#gdb.TYPE_CODE_TYPEDEF : TypeCode.Typedef, # Handled above.
gdb.TYPE_CODE_METHOD: TypeCode.Function,
gdb.TYPE_CODE_VOID: TypeCode.Void,
@@ -372,38 +363,60 @@ class Dumper(DumperBase):
gdb.TYPE_CODE_COMPLEX: TypeCode.Complex,
gdb.TYPE_CODE_STRING: TypeCode.FortranString,
}[code]
- if tdata.code == TypeCode.Enum:
- tdata.enumDisplay = lambda intval, addr, form: \
+ self.type_name_cache[typeid] = str(nativeType)
+ self.type_size_cache[typeid] = nativeType.sizeof
+ self.type_code_cache[typeid] = type_code
+ self.type_nativetype_cache[typeid] = nativeType
+
+ if type_code == TypeCode.Enum:
+ self.type_enum_display_cache[typeid] = lambda intval, addr, form: \
self.nativeTypeEnumDisplay(nativeType, intval, form)
- if tdata.code == TypeCode.Struct:
- tdata.lalignment = lambda: \
- self.nativeStructAlignment(nativeType)
- tdata.lfields = lambda value: \
- self.listMembers(value, nativeType)
- tdata.templateArguments = lambda: \
- self.listTemplateParameters(nativeType)
- # warn('CREATE TYPE: %s' % typeId)
- #else:
- # warn('REUSE TYPE: %s' % typeId)
- return self.Type(self, typeId)
-
- def listTemplateParameters(self, nativeType):
- targs = []
- pos = 0
- while True:
- try:
- targ = nativeType.template_argument(pos)
- except:
- break
- if isinstance(targ, gdb.Type):
- targs.append(self.fromNativeType(targ.unqualified()))
- elif isinstance(targ, gdb.Value):
- targs.append(self.fromNativeValue(targ).value())
- else:
- raise RuntimeError('UNKNOWN TEMPLATE PARAMETER')
- pos += 1
- targs2 = self.listTemplateParametersManually(str(nativeType))
- return targs if len(targs) >= len(targs2) else targs2
+
+ self.type_nativetype_cache[typeid] = nativeType
+
+# FIXME: Field offset caching (or later extraction?) broken
+# if code == gdb.TYPE_CODE_STRUCT:
+# field_type_name = self.type_name_cache.get(typeid, '')
+# #self.warn("CACHING FIELDS OF %s '%s'" % (typeid, field_type_name))
+# try:
+# fields = nativeType.fields()
+# #self.warn("FOUND FIELDS %s" % fields)
+# except:
+# #self.warn("NO FIELDS IN %s '%s'" % (typeid, field_type_name))
+# fields = []
+# for nativeField in fields:
+# field_name = nativeField.name
+# if field_name.startswith('std::allocator'):
+# continue
+# field_bitpos = nativeField.bitpos
+# field_typeid = self.typeid_for_string(str(nativeType))
+# field_size = nativeField.type.sizeof
+# #self.warn("CACHING '%s' OF %s AT BITPOS %s SIZE %s" %
+# # (field_name, typeid, field_bitpos, field_size))
+# self.type_fields_cache[(typeid, field_name)] = self.Field(
+# name=field_name,
+# typeid=field_typeid,
+# bitpos=field_bitpos,
+# bitsize=field_size * 8
+# )
+# pass
+
+
+ #self.warn("FROM NATIVE TYPE: %s %s %s" % (typeid, id(nativeType), nativeType))
+ self.typeid_from_typekey[str(nativeType)] = typeid
+
+ return typeid
+
+ def nativeTemplateParameter(self, typeid, index, nativeType):
+ try:
+ targ = nativeType.template_argument(index)
+ except:
+ return None
+ if isinstance(targ, gdb.Type):
+ return self.Type(self, self.from_native_type(targ.unqualified()))
+ if isinstance(targ, gdb.Value):
+ return self.fromNativeValue(targ).value()
+ raise RuntimeError('UNKNOWN TEMPLATE PARAMETER')
def nativeTypeEnumDisplay(self, nativeType, intval, form):
try:
@@ -432,7 +445,7 @@ class Dumper(DumperBase):
pass
return form % intval
- def nativeTypeId(self, nativeType):
+ def native_type_key(self, nativeType):
if nativeType and (nativeType.code == gdb.TYPE_CODE_TYPEDEF):
return '%s{%s}' % (nativeType, nativeType.strip_typedefs())
name = str(nativeType)
@@ -444,133 +457,106 @@ class Dumper(DumperBase):
c = 's'
else:
return name
- typeId = c + ''.join(['{%s:%s}' % (f.name, self.nativeTypeId(f.type))
- for f in nativeType.fields()])
- return typeId
-
- def nativeStructAlignment(self, nativeType):
- #DumperBase.warn('NATIVE ALIGN FOR %s' % nativeType.name)
- def handleItem(nativeFieldType, align):
- a = self.fromNativeType(nativeFieldType).alignment()
- return a if a > align else align
- align = 1
- for f in nativeType.fields():
- align = handleItem(f.type, align)
- return align
-
- #except:
- # # Happens in the BoostList dumper for a 'const bool'
- # # item named 'constant_time_size'. There isn't anything we can do
- # # in this case.
- # pass
+ id_str = c + ''.join(['{%s:%s}' %
+ (f.name, self.typeid_for_string(self.native_type_key(f.type)))
+ for f in nativeType.fields()])
+ #self.warn("NATIVE TYPE KEY: %s" % id_str)
+ return id_str
- #yield value.extractField(field)
-
- def memberFromNativeFieldAndValue(self, nativeField, nativeValue, fieldName, value):
- nativeMember = self.nativeMemberFromField(nativeValue, nativeField)
- if nativeMember is None:
- val = self.Value(self)
- val.name = fieldName
- val._type = self.fromNativeType(nativeField.type)
- val.lIsInScope = False
- return val
- val = self.fromNativeValue(nativeMember)
- nativeFieldType = nativeField.type.unqualified()
- if nativeField.bitsize:
- val.lvalue = int(nativeMember)
- val.laddress = None
- fieldType = self.fromNativeType(nativeFieldType)
- val._type = self.createBitfieldType(fieldType, nativeField.bitsize)
- val.isBaseClass = nativeField.is_base_class
- val.name = fieldName
- return val
-
- def nativeMemberFromField(self, nativeValue, nativeField):
- if nativeField.is_base_class:
- return nativeValue.cast(nativeField.type)
- try:
- return nativeValue[nativeField]
- except:
- pass
- try:
- return nativeValue[nativeField.name]
- except:
- pass
- return None
-
- def listMembers(self, value, nativeType):
+ def nativeListMembers(self, value, nativeType, include_base):
nativeValue = value.nativeValue
+ value_size = self.type_size(value.typeid)
+ ldata = bytes(self.value_data(value, value_size))
+ laddress = value.laddress
anonNumber = 0
- #DumperBase.warn('LISTING FIELDS FOR %s' % nativeType)
+ fields = []
+ #self.warn('LISTING FIELDS FOR %s' % nativeType)
for nativeField in nativeType.fields():
- fieldName = nativeField.name
+ if not include_base and nativeField.is_base_class:
+ continue
+
+ field_name = nativeField.name
# Something without a name.
# Anonymous union? We need a dummy name to distinguish
# multiple anonymous unions in the struct.
# Since GDB commit b5b08fb4 anonymous structs get also reported
# with a 'None' name.
- if fieldName is None or len(fieldName) == 0:
- # Something without a name.
- # Anonymous union? We need a dummy name to distinguish
- # multiple anonymous unions in the struct.
+ if field_name is None or len(field_name) == 0:
anonNumber += 1
- fieldName = '#%s' % anonNumber
- #DumperBase.warn('FIELD: %s' % fieldName)
+ field_name = '#%s' % anonNumber
+ #self.warn('FIELD: %s' % field_name)
+
+ nativeFieldType = nativeField.type.unqualified()
+ field_typeid = self.from_native_type(nativeFieldType)
+ #self.warn(' TYPE: %s' % nativeFieldType)
+ #self.warn(' TYPE KEY: %s' % self.native_type_key(nativeFieldType))
+
+ if nativeValue is not None:
+ try:
+ native_member = nativeValue[nativeField]
+ except:
+ self.warn(' COULD NOT ACCESS FIELD: %s' % nativeFieldType)
+ continue
+
+ val = self.fromNativeValue(native_member)
+ if nativeField.bitsize:
+ val.lvalue = None
+ val.ldata = int(native_member)
+ val.laddress = None
+ val.typeid = self.create_bitfield_typeid(field_typeid, nativeField.bitsize)
+ val.isBaseClass = nativeField.is_base_class
+ val.name = field_name
+ fields.append(val)
+ continue
+
# hasattr(nativeField, 'bitpos') == False indicates a static field,
- # but if we have access to a nativeValue .fromNativeField will
+ # but if we have access to a nativeValue, so fromNativeField will
# also succeed. We essentially skip only static members from
# artificial values, like array members constructed from address.
- if hasattr(nativeField, 'bitpos') or nativeValue is not None:
- yield self.fromNativeField(nativeField, nativeValue, fieldName)
+ if not hasattr(nativeField, 'bitpos'):
+ continue
- def fromNativeField(self, nativeField, nativeValue, fieldName):
- nativeFieldType = nativeField.type.unqualified()
- #DumperBase.warn(' TYPE: %s' % nativeFieldType)
- #DumperBase.warn(' TYPEID: %s' % self.nativeTypeId(nativeFieldType))
-
- if hasattr(nativeField, 'bitpos'):
bitpos = nativeField.bitpos
- else:
- bitpos = 0
- if hasattr(nativeField, 'bitsize') and nativeField.bitsize != 0:
- bitsize = nativeField.bitsize
- else:
- bitsize = 8 * nativeFieldType.sizeof
+ if hasattr(nativeField, 'bitsize') and nativeField.bitsize != 0:
+ bitsize = nativeField.bitsize
+ else:
+ bitsize = 8 * nativeFieldType.sizeof
- fieldType = self.fromNativeType(nativeFieldType)
- if bitsize != nativeFieldType.sizeof * 8:
- fieldType = self.createBitfieldType(fieldType, bitsize)
- else:
- fieldType = fieldType
+ field_typeid = self.from_native_type(nativeFieldType)
+ is_bitfield = bitsize != nativeFieldType.sizeof * 8
+
+ val = self.Value(self)
+ val.name = field_name
+ val.isBaseClass = nativeField.is_base_class
+
+ if is_bitfield:
+ val.typeid = self.create_bitfield_typeid(field_typeid, bitsize)
+ val.ldata = self.value_extract_bits(value, bitpos, bitsize)
+ else:
+ val.typeid = field_typeid
+ field_offset = bitpos // 8
+ if laddress is not None:
+ val.laddress = laddress + field_offset
+ field_size = (bitsize + 7) // 8
+ val.ldata = ldata[field_offset:field_offset + field_size]
+
+ #self.warn('GOT VAL %s FOR FIELD %s' % (val, nativeField))
+ fields.append(val)
+
+ return fields
- if nativeValue is None:
- extractor = None
- else:
- extractor = lambda value, \
- capturedNativeField = nativeField, \
- capturedNativeValue = nativeValue, \
- capturedFieldName = fieldName: \
- self.memberFromNativeFieldAndValue(capturedNativeField,
- capturedNativeValue,
- capturedFieldName,
- value)
-
- #DumperBase.warn("FOUND NATIVE FIELD: %s bitpos: %s" % (fieldName, bitpos))
- return self.Field(dumper=self, name=fieldName, isBase=nativeField.is_base_class,
- bitsize=bitsize, bitpos=bitpos, type=fieldType,
- extractor=extractor)
def listLocals(self, partialVar):
frame = gdb.selected_frame()
try:
block = frame.block()
- #DumperBase.warn('BLOCK: %s ' % block)
+ #self.warn('BLOCK: %s ' % block)
except RuntimeError as error:
- #DumperBase.warn('BLOCK IN FRAME NOT ACCESSIBLE: %s' % error)
+ #self.warn('BLOCK IN FRAME NOT ACCESSIBLE: %s' % error)
return []
except:
self.warn('BLOCK NOT ACCESSIBLE FOR UNKNOWN REASONS')
@@ -594,14 +580,12 @@ class Dumper(DumperBase):
if partialVar is not None and partialVar != name:
continue
- # 'NotImplementedError: Symbol type not yet supported in
- # Python scripts.'
- #DumperBase.warn('SYMBOL %s (%s, %s)): ' % (symbol, name, symbol.name))
+ #self.warn('SYMBOL %s (%s, %s)): ' % (symbol, name, symbol.name))
if self.passExceptions and not self.isTesting:
nativeValue = frame.read_var(name, block)
value = self.fromFrameValue(nativeValue)
value.name = name
- #DumperBase.warn('READ 0: %s' % value.stringify())
+ #self.warn('READ 0: %s' % value.stringify())
items.append(value)
continue
@@ -610,14 +594,14 @@ class Dumper(DumperBase):
nativeValue = frame.read_var(name, block)
value = self.fromFrameValue(nativeValue)
value.name = name
- #DumperBase.warn('READ 1: %s' % value.stringify())
+ #self.warn('READ 1: %s' % value.stringify())
items.append(value)
continue
except:
pass
try:
- #DumperBase.warn('READ 2: %s' % item.value)
+ #self.warn('READ 2: %s' % item.value)
value = self.fromFrameValue(frame.read_var(name))
value.name = name
items.append(value)
@@ -631,8 +615,8 @@ class Dumper(DumperBase):
pass
try:
- #DumperBase.warn('READ 3: %s %s' % (name, item.value))
- #DumperBase.warn('ITEM 3: %s' % item.value)
+ #self.warn('READ 3: %s %s' % (name, item.value))
+ #self.warn('ITEM 3: %s' % item.value)
value = self.fromFrameValue(gdb.parse_and_eval(name))
value.name = name
items.append(value)
@@ -661,16 +645,17 @@ class Dumper(DumperBase):
return self.ptrSize() == 8
def fetchVariables(self, args):
+ start_time = time.perf_counter()
self.resetStats()
self.prepare(args)
self.isBigEndian = gdb.execute('show endian', to_string=True).find('big endian') > 0
self.packCode = '>' if self.isBigEndian else '<'
- (ok, res) = self.tryFetchInterpreterVariables(args)
- if ok:
- safePrint(res)
- return
+ #(ok, res) = self.tryFetchInterpreterVariables(args)
+ #if ok:
+ # safePrint(res)
+ # return
self.put('data=[')
@@ -679,7 +664,7 @@ class Dumper(DumperBase):
partialName = partialVar.split('.')[1].split('@')[0] if isPartial else None
variables = self.listLocals(partialName)
- #DumperBase.warn('VARIABLES: %s' % variables)
+ #self.warn('VARIABLES: %s' % variables)
# Take care of the return value of the last function call.
if len(self.resultVarName) > 0:
@@ -711,9 +696,12 @@ class Dumper(DumperBase):
self.put(',qtnamespace="%s"' % self.qtNamespaceToReport)
self.qtNamespaceToReport = None
+ run_time = time.perf_counter() - start_time
+ #self.warn("PTIME: %s" % run_time)
self.put(',partial="%d"' % isPartial)
+ self.put(',runtime="%s"' % run_time)
self.put(',counts=%s' % self.counts)
- self.put(',timings=%s' % self.timings)
+ #self.put(',timings=%s' % self.timings)
self.reportResult(''.join(self.output), args)
def parseAndEvaluate(self, exp):
@@ -721,7 +709,7 @@ class Dumper(DumperBase):
return None if val is None else self.fromNativeValue(val)
def nativeParseAndEvaluate(self, exp):
- #DumperBase.warn('EVALUATE "%s"' % exp)
+ #self.warn('EVALUATE "%s"' % exp)
try:
val = gdb.parse_and_eval(exp)
return val
@@ -744,20 +732,20 @@ class Dumper(DumperBase):
else:
arg += a
- #DumperBase.warn('CALL: %s -> %s(%s)' % (value, function, arg))
- typeName = value.type.name
- if typeName.find(':') >= 0:
- typeName = "'" + typeName + "'"
+ #self.warn('CALL: %s -> %s(%s)' % (value, function, arg))
+ type_name = value.type.name
+ if type_name.find(':') >= 0:
+ type_name = "'" + type_name + "'"
# 'class' is needed, see http://sourceware.org/bugzilla/show_bug.cgi?id=11912
- #exp = '((class %s*)%s)->%s(%s)' % (typeName, value.laddress, function, arg)
+ #exp = '((class %s*)%s)->%s(%s)' % (type_name, value.laddress, function, arg)
addr = value.address()
if addr is None:
addr = self.pokeValue(value)
- #DumperBase.warn('PTR: %s -> %s(%s)' % (value, function, addr))
- exp = '((%s*)0x%x)->%s(%s)' % (typeName, addr, function, arg)
- #DumperBase.warn('CALL: %s' % exp)
+ #self.warn('PTR: %s -> %s(%s)' % (value, function, addr))
+ exp = '((%s*)0x%x)->%s(%s)' % (type_name, addr, function, arg)
+ #self.warn('CALL: %s' % exp)
result = gdb.parse_and_eval(exp)
- #DumperBase.warn(' -> %s' % result)
+ #self.warn(' -> %s' % result)
res = self.fromNativeValue(result)
if value.address() is None:
self.releaseValue(addr)
@@ -765,9 +753,9 @@ class Dumper(DumperBase):
def makeExpression(self, value):
typename = '::' + value.type.name
- #DumperBase.warn(' TYPE: %s' % typename)
+ #self.warn(' TYPE: %s' % typename)
exp = '(*(%s*)(0x%x))' % (typename, value.address())
- #DumperBase.warn(' EXP: %s' % exp)
+ #self.warn(' EXP: %s' % exp)
return exp
def makeStdString(init):
@@ -785,14 +773,14 @@ class Dumper(DumperBase):
size = value.type.size()
data = value.data()
h = self.hexencode(data)
- #DumperBase.warn('DATA: %s' % h)
+ #self.warn('DATA: %s' % h)
string = ''.join('\\x' + h[2 * i:2 * i + 2] for i in range(size))
exp = '(%s*)memcpy(calloc(1, %d), "%s", %d)' \
% (value.type.name, size, string, size)
- #DumperBase.warn('EXP: %s' % exp)
+ #self.warn('EXP: %s' % exp)
res = gdb.parse_and_eval(exp)
- #DumperBase.warn('RES: %s' % res)
- return toInteger(res)
+ #self.warn('RES: %s' % res)
+ return int(res)
def releaseValue(self, address):
gdb.parse_and_eval('free(0x%x)' % address)
@@ -819,7 +807,7 @@ class Dumper(DumperBase):
return self.cachedInferior
def readRawMemory(self, address, size):
- #DumperBase.warn('READ: %s FROM 0x%x' % (size, address))
+ #self.warn('READ: %s FROM 0x%x' % (size, address))
if address == 0 or size == 0:
return bytes()
res = self.selectedInferior().read_memory(address, size)
@@ -832,7 +820,7 @@ class Dumper(DumperBase):
return 0
try:
# Older GDB ~7.4 don't have gdb.Symbol.value()
- return toInteger(symbol.value().address)
+ return int(symbol.value().address)
except:
pass
@@ -1020,7 +1008,7 @@ class Dumper(DumperBase):
def findSymbol(self, symbolName):
try:
- return toInteger(gdb.parse_and_eval("(size_t)&'%s'" % symbolName))
+ return int(gdb.parse_and_eval("(size_t)&'%s'" % symbolName))
except:
return 0
@@ -1052,30 +1040,24 @@ class Dumper(DumperBase):
def handleQtCoreLoaded(self, objfile):
fd, tmppath = tempfile.mkstemp()
os.close(fd)
- try:
- cmd = 'maint print msymbols -objfile "%s" -- %s' % (objfile.filename, tmppath)
- symbols = gdb.execute(cmd, to_string=True)
- except:
- try:
- # command syntax depends on gdb version - below is gdb < 8
- cmd = 'maint print msymbols %s "%s"' % (tmppath, objfile.filename)
- symbols = gdb.execute(cmd, to_string=True)
- except:
- pass
+ cmd = 'maint print msymbols -objfile "%s" -- %s' % (objfile.filename, tmppath)
+ symbols = gdb.execute(cmd, to_string=True)
ns = ''
with open(tmppath) as f:
+ ns1re = re.compile(r'_ZN?(\d*)(\w*)L17msgHandlerGrabbedE? ')
+ ns2re = re.compile(r'_ZN?(\d*)(\w*)L17currentThreadDataE? ')
for line in f:
- if line.find('msgHandlerGrabbed ') >= 0:
+ if 'msgHandlerGrabbed ' in line:
# [11] b 0x7ffff683c000 _ZN4MynsL17msgHandlerGrabbedE
# section .tbss Myns::msgHandlerGrabbed qlogging.cpp
- ns = re.split(r'_ZN?(\d*)(\w*)L17msgHandlerGrabbedE? ', line)[2]
+ ns = ns1re.split(line)[2]
if len(ns):
ns += '::'
break
- if line.find('currentThreadData ') >= 0:
+ if 'currentThreadData ' in line:
# [ 0] b 0x7ffff67d3000 _ZN2UUL17currentThreadDataE
# section .tbss UU::currentThreadData qthread_unix.cpp\\n
- ns = re.split(r'_ZN?(\d*)(\w*)L17currentThreadDataE? ', line)[2]
+ ns = ns2re.split(line)[2]
if len(ns):
ns += '::'
break
@@ -1104,21 +1086,21 @@ class Dumper(DumperBase):
self.qtPropertyFunc = self.findSymbol(sym)
def assignValue(self, args):
- typeName = self.hexdecode(args['type'])
+ type_name = self.hexdecode(args['type'])
expr = self.hexdecode(args['expr'])
value = self.hexdecode(args['value'])
simpleType = int(args['simpleType'])
ns = self.qtNamespace()
- if typeName.startswith(ns):
- typeName = typeName[len(ns):]
- typeName = typeName.replace('::', '__')
- pos = typeName.find('<')
+ if type_name.startswith(ns):
+ type_name = type_name[len(ns):]
+ type_name = type_name.replace('::', '__')
+ pos = type_name.find('<')
if pos != -1:
- typeName = typeName[0:pos]
- if typeName in self.qqEditable and not simpleType:
- #self.qqEditable[typeName](self, expr, value)
+ type_name = type_name[0:pos]
+ if type_name in self.qqEditable and not simpleType:
+ #self.qqEditable[type_name](self, expr, value)
expr = self.parseAndEvaluate(expr)
- self.qqEditable[typeName](self, expr, value)
+ self.qqEditable[type_name](self, expr, value)
else:
cmd = 'set variable (%s)=%s' % (expr, value)
gdb.execute(cmd)
@@ -1152,63 +1134,28 @@ class Dumper(DumperBase):
nativeValue = value.nativeValue
return self.fromNativeValue(nativeValue.cast(nativeValue.type.target()))
- def nativeDynamicTypeName(self, address, baseType):
- # Needed for Gdb13393 test.
- nativeType = self.lookupNativeType(baseType.name)
- if nativeType is None:
- return None
- nativeTypePointer = nativeType.pointer()
- nativeValue = gdb.Value(address).cast(nativeTypePointer).dereference()
- val = nativeValue.cast(nativeValue.dynamic_type)
- return str(val.type)
- #try:
- # vtbl = gdb.execute('info symbol {%s*}0x%x' % (baseType.name, address), to_string = True)
- #except:
- # return None
- #pos1 = vtbl.find('vtable ')
- #if pos1 == -1:
- # return None
- #pos1 += 11
- #pos2 = vtbl.find(' +', pos1)
- #if pos2 == -1:
- # return None
- #return vtbl[pos1 : pos2]
-
- def nativeDynamicType(self, address, baseType):
+ def nativeDynamicType(self, address, base_typeid):
# Needed for Gdb13393 test.
- nativeType = self.lookupNativeType(baseType.name)
+ nativeType = self.type_nativetype_cache.get(base_typeid, None)
if nativeType is None:
- return baseType
+ return base_typeid
nativeTypePointer = nativeType.pointer()
nativeValue = gdb.Value(address).cast(nativeTypePointer).dereference()
- return self.fromNativeType(nativeValue.dynamic_type)
+ return self.from_native_type(nativeValue.dynamic_type)
def enumExpression(self, enumType, enumValue):
return self.qtNamespace() + 'Qt::' + enumValue
- def lookupNativeType(self, typeName):
- nativeType = self.lookupNativeTypeHelper(typeName)
- if nativeType is not None:
- self.check(isinstance(nativeType, gdb.Type))
- return nativeType
-
- def lookupNativeTypeHelper(self, typeName):
- typeobj = self.typeCache.get(typeName)
- #DumperBase.warn('LOOKUP 1: %s -> %s' % (typeName, typeobj))
- if typeobj is not None:
- return typeobj
-
- if typeName == 'void':
- typeobj = gdb.lookup_type(typeName)
- self.typeCache[typeName] = typeobj
- self.typesToReport[typeName] = typeobj
+ def lookupNativeType(self, type_name):
+ if type_name == 'void':
+ typeobj = gdb.lookup_type(type_name)
+ self.typesToReport[type_name] = typeobj
return typeobj
#try:
- # typeobj = gdb.parse_and_eval('{%s}&main' % typeName).typeobj
+ # typeobj = gdb.parse_and_eval('{%s}&main' % type_name).typeobj
# if not typeobj is None:
- # self.typeCache[typeName] = typeobj
- # self.typesToReport[typeName] = typeobj
+ # self.typesToReport[type_name] = typeobj
# return typeobj
#except:
# pass
@@ -1217,22 +1164,21 @@ class Dumper(DumperBase):
# gcc produces '{anonymous}', gdb '(anonymous namespace)'
# '<unnamed>' has been seen too. The only thing gdb
# understands when reading things back is '(anonymous namespace)'
- if typeName.find('{anonymous}') != -1:
- ts = typeName
+ if type_name.find('{anonymous}') != -1:
+ ts = type_name
ts = ts.replace('{anonymous}', '(anonymous namespace)')
typeobj = self.lookupNativeType(ts)
if typeobj is not None:
- self.typeCache[typeName] = typeobj
- self.typesToReport[typeName] = typeobj
+ self.typesToReport[type_name] = typeobj
return typeobj
- #DumperBase.warn(" RESULT FOR 7.2: '%s': %s" % (typeName, typeobj))
+ #self.warn(" RESULT FOR 7.2: '%s': %s" % (type_name, typeobj))
# This part should only trigger for
# gdb 7.1 for types with namespace separators.
# And anonymous namespaces.
- ts = typeName
+ ts = type_name
while True:
if ts.startswith('class '):
ts = ts[6:]
@@ -1259,36 +1205,32 @@ class Dumper(DumperBase):
typeobj = self.lookupNativeType(ts[0:-1])
if typeobj is not None:
typeobj = typeobj.pointer()
- self.typeCache[typeName] = typeobj
- self.typesToReport[typeName] = typeobj
+ self.typesToReport[type_name] = typeobj
return typeobj
try:
- #DumperBase.warn("LOOKING UP 1 '%s'" % ts)
+ #self.warn("LOOKING UP 1 '%s'" % ts)
typeobj = gdb.lookup_type(ts)
except RuntimeError as error:
- #DumperBase.warn("LOOKING UP 2 '%s' ERROR %s" % (ts, error))
+ #self.warn("LOOKING UP '%s' FAILED" % ts)
+ pass
+ #self.warn("LOOKING UP 2 '%s' ERROR %s" % (ts, error))
# See http://sourceware.org/bugzilla/show_bug.cgi?id=11912
exp = "(class '%s'*)0" % ts
try:
typeobj = self.parse_and_eval(exp).type.target()
- #DumperBase.warn("LOOKING UP 3 '%s'" % typeobj)
+ #self.warn("LOOKING UP 3 '%s'" % typeobj)
except:
# Can throw 'RuntimeError: No type named class Foo.'
pass
- except:
- #DumperBase.warn("LOOKING UP '%s' FAILED" % ts)
- pass
if typeobj is not None:
- #DumperBase.warn('CACHING: %s' % typeobj)
- self.typeCache[typeName] = typeobj
- self.typesToReport[typeName] = typeobj
+ #self.warn('CACHING: %s' % typeobj)
+ self.typesToReport[type_name] = typeobj
# This could still be None as gdb.lookup_type('char[3]') generates
# 'RuntimeError: No type named char[3]'
- #self.typeCache[typeName] = typeobj
- #self.typesToReport[typeName] = typeobj
+ #self.typesToReport[type_name] = typeobj
return typeobj
def doContinue(self):
@@ -1332,7 +1274,7 @@ class Dumper(DumperBase):
if typeobj.code == gdb.TYPE_CODE_PTR:
dereftype = typeobj.target().unqualified()
if dereftype.name == needle:
- addr = toInteger(value)
+ addr = int(value)
res = None
for pat in pats:
try:
@@ -1442,14 +1384,6 @@ class Dumper(DumperBase):
def reportResult(self, result, args):
print('result={token="%s",%s}' % (args.get("token", 0), result))
- def profile1(self, args):
- '''Internal profiling'''
- import cProfile
- tempDir = tempfile.gettempdir() + '/bbprof'
- cProfile.run('theDumper.fetchVariables(%s)' % args, tempDir)
- import pstats
- pstats.Stats(tempDir).sort_stats('time').print_stats()
-
def profile2(self, args):
import timeit
print(timeit.repeat('theDumper.fetchVariables(%s)' % args,
diff --git a/share/qtcreator/debugger/lldbbridge.py b/share/qtcreator/debugger/lldbbridge.py
index b64d115a0a..6b08ac3d32 100644
--- a/share/qtcreator/debugger/lldbbridge.py
+++ b/share/qtcreator/debugger/lldbbridge.py
@@ -116,33 +116,29 @@ class Dumper(DumperBase):
self.isInterrupting_ = False
self.interpreterBreakpointResolvers = []
- DumperBase.warn = Dumper.warn_impl
self.report('lldbversion=\"%s\"' % lldb.SBDebugger.GetVersionString())
- @staticmethod
- def warn_impl(message):
- if message[-1:] == '\n':
- message += '\n'
+ def warn(self, msg):
+ #self.put('{name="%s",value="",type="",numchild="0"},' % toCString(msg))
+ if msg[-1:] == '\n':
+ msg += '\n'
print('@\nbridgemessage={msg="%s",channel="%s"}\n@'
- % (message.replace('"', '$'), LogChannel.AppError))
-
- def fromNativeFrameValue(self, nativeValue):
- return self.fromNativeValue(nativeValue)
+ % (msg.replace('"', '$'), LogChannel.AppError))
def fromNativeValue(self, nativeValue):
self.check(isinstance(nativeValue, lldb.SBValue))
nativeType = nativeValue.GetType()
- typeName = nativeType.GetName()
+ type_name = nativeType.GetName()
code = nativeType.GetTypeClass()
# Display the result of GetSummary() for Core Foundation string
# and string-like types.
summary = None
if self.useFancy:
- if (typeName.startswith('CF')
- or typeName.startswith('__CF')
- or typeName.startswith('NS')
- or typeName.startswith('__NSCF')):
+ if (type_name.startswith('CF')
+ or type_name.startswith('__CF')
+ or type_name.startswith('NS')
+ or type_name.startswith('__NSCF')):
if code == lldb.eTypeClassPointer:
summary = nativeValue.Dereference().GetSummary()
elif code == lldb.eTypeClassReference:
@@ -156,26 +152,26 @@ class Dumper(DumperBase):
nativeTargetType = nativeType.GetDereferencedType()
if not nativeTargetType.IsPointerType():
nativeTargetType = nativeTargetType.GetUnqualifiedType()
- targetType = self.fromNativeType(nativeTargetType)
- val = self.createReferenceValue(nativeValue.GetValueAsUnsigned(), targetType)
+ target_typeid = self.from_native_type(nativeTargetType)
+ target_address = nativeValue.GetValueAsUnsigned()
+ val = self.Value(self)
+ val.ldata = target_address.to_bytes(self.ptrSize(), 'little')
+ if self.useDynamicType:
+ target_typeid = self.dynamic_typeid_at_address(target_typeid, target_address)
+ val.typeid = self.create_reference_typeid(target_typeid)
val.laddress = nativeValue.AddressOf().GetValueAsUnsigned()
- #DumperBase.warn('CREATED REF: %s' % val)
+ #self.warn('CREATED REF: %s' % val)
+
elif code == lldb.eTypeClassPointer:
nativeTargetType = nativeType.GetPointeeType()
if not nativeTargetType.IsPointerType():
nativeTargetType = nativeTargetType.GetUnqualifiedType()
- targetType = self.fromNativeType(nativeTargetType)
- val = self.createPointerValue(nativeValue.GetValueAsUnsigned(), targetType)
- #DumperBase.warn('CREATED PTR 1: %s' % val)
+ target_typeid = self.from_native_type(nativeTargetType)
+ val = self.Value(self)
+ val.ldata = nativeValue.GetValueAsUnsigned()
+ val.typeid = self.create_pointer_typeid(target_typeid)
val.laddress = nativeValue.AddressOf().GetValueAsUnsigned()
- #DumperBase.warn('CREATED PTR 2: %s' % val)
- elif code == lldb.eTypeClassTypedef:
- nativeTargetType = nativeType.GetUnqualifiedType()
- if hasattr(nativeTargetType, 'GetCanonicalType'):
- nativeTargetType = nativeTargetType.GetCanonicalType()
- val = self.fromNativeValue(nativeValue.Cast(nativeTargetType))
- val._type = self.fromNativeType(nativeType)
- #DumperBase.warn('CREATED TYPEDEF: %s' % val)
+
else:
val = self.Value(self)
address = nativeValue.GetLoadAddress()
@@ -193,7 +189,7 @@ class Dumper(DumperBase):
except:
pass
- val._type = self.fromNativeType(nativeType)
+ val.typeid = self.from_native_type(nativeType)
if code == lldb.eTypeClassEnumeration:
intval = nativeValue.GetValueAsSigned()
@@ -209,43 +205,32 @@ class Dumper(DumperBase):
val.ldisplay = str(nativeValue.GetValue())
#elif code == lldb.eTypeClassArray:
# if hasattr(nativeType, 'GetArrayElementType'): # New in 3.8(?) / 350.x
- # val.type.ltarget = self.fromNativeType(nativeType.GetArrayElementType())
+ # val.type.ltarget = self.from_native_type(nativeType.GetArrayElementType())
# else:
# fields = nativeType.get_fields_array()
# if len(fields):
- # val.type.ltarget = self.fromNativeType(fields[0])
+ # val.type.ltarget = self.from_native_type(fields[0])
#elif code == lldb.eTypeClassVector:
- # val.type.ltarget = self.fromNativeType(nativeType.GetVectorElementType())
+ # val.type.ltarget = self.from_native_type(nativeType.GetVectorElementType())
val.summary = summary
val.lIsInScope = nativeValue.IsInScope()
val.name = nativeValue.GetName()
return val
- def nativeStructAlignment(self, nativeType):
- def handleItem(nativeFieldType, align):
- a = self.fromNativeType(nativeFieldType).alignment()
- return a if a > align else align
- align = 1
- for i in range(nativeType.GetNumberOfDirectBaseClasses()):
- base = nativeType.GetDirectBaseClassAtIndex(i)
- align = handleItem(base.GetType(), align)
- for i in range(nativeType.GetNumberOfFields()):
- child = nativeType.GetFieldAtIndex(i)
- align = handleItem(child.GetType(), align)
- return align
-
- def listMembers(self, value, nativeType):
- #DumperBase.warn("ADDR: 0x%x" % self.fakeAddress_)
- if value.laddress:
- fakeAddress = lldb.SBAddress(value.laddress, self.target)
- fakeLAddress = value.laddress
- else:
- fakeAddress = self.fakeAddress_
- fakeLAddress = self.fakeLAddress_
+ def nativeListMembers(self, value, nativeType, include_base):
+ #self.warn("ADDR: 0x%x" % self.fakeAddress_)
+ nativeValue = value.nativeValue
+ if nativeValue is None:
+ if value.laddress:
+ fakeAddress = lldb.SBAddress(value.laddress, self.target)
+ fakeLAddress = value.laddress
+ else:
+ fakeAddress = self.fakeAddress_
+ fakeLAddress = self.fakeLAddress_
+ nativeValue = self.target.CreateValueFromAddress('x', fakeAddress, nativeType)
- fakeValue = self.target.CreateValueFromAddress('x', fakeAddress, nativeType)
- fakeValue.SetPreferSyntheticValue(False)
+ nativeValue.SetPreferSyntheticValue(False)
baseNames = {}
for i in range(nativeType.GetNumberOfDirectBaseClasses()):
@@ -262,86 +247,99 @@ class Dumper(DumperBase):
# Normal members and non-empty base classes.
anonNumber = 0
- for i in range(fakeValue.GetNumChildren()):
- nativeField = fakeValue.GetChildAtIndex(i)
+
+ fields = []
+ for i in range(nativeValue.GetNumChildren()):
+ nativeField = nativeValue.GetChildAtIndex(i)
nativeField.SetPreferSyntheticValue(False)
fieldName = nativeField.GetName()
nativeFieldType = nativeField.GetType()
if fieldName in fieldBits:
- (fieldBitsize, fieldBitpos, isBitfield) = fieldBits[fieldName]
+ (bitsize, bitpos, isBitfield) = fieldBits[fieldName]
else:
- fieldBitsize = nativeFieldType.GetByteSize() * 8
- fieldBitpos = None
+ bitsize = nativeFieldType.GetByteSize() * 8
+ bitpos = None
isBitfield = False
if isBitfield: # Bit fields
- fieldType = self.createBitfieldType(
- self.createType(self.typeName(nativeFieldType)), fieldBitsize)
- yield self.Field(self, name=fieldName, type=fieldType,
- bitsize=fieldBitsize, bitpos=fieldBitpos)
+ field_typeid = self.create_bitfield_typeid(
+ self.create_typeid(nativeFieldType.GetName()), bitsize)
+ val = self.Value(self)
+ val.name = fieldName
+ val.isBaseClass = False
+ val.typeid = field_typeid
+ val.ldata = self.value_extract_bits(value, bitpos, bitsize)
+ val.laddress = None
+ fields.append(val)
elif fieldName is None: # Anon members
anonNumber += 1
fieldName = '#%s' % anonNumber
- fakeMember = fakeValue.GetChildAtIndex(i)
+ fakeMember = nativeValue.GetChildAtIndex(i)
fakeMemberAddress = fakeMember.GetLoadAddress()
- offset = fakeMemberAddress - fakeLAddress
- yield self.Field(self, name=fieldName, type=self.fromNativeType(nativeFieldType),
- bitsize=fieldBitsize, bitpos=8 * offset)
+ val = self.Value(self)
+ val.name = fieldName
+ val.isBaseClass = False
+ val.typeid = typeid=self.from_native_type(nativeFieldType)
+ field_offset = fakeMemberAddress - fakeLAddress
+ if value.laddress is not None:
+ val.laddress = value.laddress + field_offset
+ if value.ldata is not None:
+ field_size = (bitsize + 7) // 8
+ val.ldata = value.ldata[field_offset:field_offset + field_size]
+ fields.append(val)
elif fieldName in baseNames: # Simple bases
- member = self.fromNativeValue(fakeValue.GetChildAtIndex(i))
+ member = self.fromNativeValue(nativeValue.GetChildAtIndex(i))
member.isBaseClass = True
- yield member
+ fields.append(member)
else: # Normal named members
- member = self.fromNativeValue(fakeValue.GetChildAtIndex(i))
+ member = self.fromNativeValue(nativeValue.GetChildAtIndex(i))
member.name = nativeField.GetName()
- yield member
-
- # Empty bases are not covered above.
- for i in range(nativeType.GetNumberOfDirectBaseClasses()):
- fieldObj = nativeType.GetDirectBaseClassAtIndex(i)
- fieldType = fieldObj.GetType()
- if fieldType.GetNumberOfFields() == 0:
- if fieldType.GetNumberOfDirectBaseClasses() == 0:
- member = self.Value(self)
- fieldName = fieldObj.GetName()
- member._type = self.fromNativeType(fieldType)
- member.name = fieldName
- member.fields = []
- if False:
- # This would be correct if we came here only for
- # truly empty base classes. Alas, we don't, see below.
- member.ldata = bytes()
- member.lbitsize = fieldType.GetByteSize() * 8
- else:
- # This is a hack. LLDB 3.8 reports declared but not defined
- # types as having no fields and(!) size == 1. At least
- # for the common case of a single base class we can
- # fake the contents by using the whole derived object's
- # data as base class data.
- data = fakeValue.GetData()
- size = nativeType.GetByteSize()
- member.lbitsize = size * 8
- error = lldb.SBError()
- member.laddress = value.laddress
- member.ldata = data.ReadRawData(error, 0, size)
- member.isBaseClass = True
- member.ltype = self.fromNativeType(fieldType)
- member.name = fieldName
- yield member
+ fields.append(member)
+
+
+ if include_base:
+ # Empty bases are not covered above.
+ for i in range(nativeType.GetNumberOfDirectBaseClasses()):
+ fieldObj = nativeType.GetDirectBaseClassAtIndex(i)
+ fieldType = fieldObj.GetType()
+ if fieldType.GetNumberOfFields() == 0:
+ if fieldType.GetNumberOfDirectBaseClasses() == 0:
+ member = self.Value(self)
+ fieldName = fieldObj.GetName()
+ member.typeid = self.from_native_type(fieldType)
+ member.name = fieldName
+ member.fields = []
+ if False:
+ # This would be correct if we came here only for
+ # truly empty base classes. Alas, we don't, see below.
+ member.ldata = bytes()
+ else:
+ # This is a hack. LLDB 3.8 reports declared but not defined
+ # types as having no fields and(!) size == 1. At least
+ # for the common case of a single base class we can
+ # fake the contents by using the whole derived object's
+ # data as base class data.
+ data = nativeValue.GetData()
+ size = nativeType.GetByteSize()
+ error = lldb.SBError()
+ member.laddress = value.laddress
+ member.ldata = data.ReadRawData(error, 0, size)
+ member.isBaseClass = True
+ fields.append(member)
+ return fields
def ptrSize(self):
result = self.target.GetAddressByteSize()
self.ptrSize = lambda: result
return result
- def fromNativeType(self, nativeType):
+ def from_native_type(self, nativeType):
self.check(isinstance(nativeType, lldb.SBType))
- code = nativeType.GetTypeClass()
# eTypeClassInvalid = (0u),
# eTypeClassArray = (1u << 0),
@@ -367,43 +365,41 @@ class Dumper(DumperBase):
# // Define a mask that can be used for any type when finding types
# eTypeClassAny = (0xffffffffu)
- #DumperBase.warn('CURRENT: %s' % self.typeData.keys())
- #DumperBase.warn('FROM NATIVE TYPE: %s' % nativeType.GetName())
- if code == lldb.eTypeClassInvalid:
- return None
+ #self.warn('CURRENT: %s' % self.typeData.keys())
+ #self.warn('FROM NATIVE TYPE: %s' % nativeType.GetName())
- if code == lldb.eTypeClassBuiltin:
- nativeType = nativeType.GetUnqualifiedType()
+ typeid_str = self.native_type_key(nativeType)
+ known_typeid = self.typeid_from_typekey.get(typeid_str, None)
+ if known_typeid is not None:
+ return known_typeid
- if code == lldb.eTypeClassPointer:
- #DumperBase.warn('PTR')
- nativeTargetType = nativeType.GetPointeeType()
- if not nativeTargetType.IsPointerType():
- nativeTargetType = nativeTargetType.GetUnqualifiedType()
- #DumperBase.warn('PTR: %s' % nativeTargetType.name)
- return self.createPointerType(self.fromNativeType(nativeTargetType))
+ code = nativeType.GetTypeClass()
- if code == lldb.eTypeClassReference:
+ if code == lldb.eTypeClassInvalid:
+ typeid = 0
+
+ elif code == lldb.eTypeClassPointer:
+ #self.warn('PTR: %s' % nativeTargetType.name)
+ target_typeid = self.from_native_type(nativeType.GetPointeeType())
+ typeid = self.create_pointer_typeid(target_typeid)
+
+ elif code == lldb.eTypeClassReference:
#DumperBase.warn('REF')
- nativeTargetType = nativeType.GetDereferencedType()
- if not nativeTargetType.IsPointerType():
- nativeTargetType = nativeTargetType.GetUnqualifiedType()
- #DumperBase.warn('REF: %s' % nativeTargetType.name)
- return self.createReferenceType(self.fromNativeType(nativeTargetType))
+ target_typeid = self.from_native_type(nativeType.GetDereferencedType())
+ typeid = self.create_reference_typeid(target_typeid)
- if code == lldb.eTypeClassTypedef:
+ elif code == lldb.eTypeClassTypedef:
#DumperBase.warn('TYPEDEF')
nativeTargetType = nativeType.GetUnqualifiedType()
if hasattr(nativeTargetType, 'GetCanonicalType'):
nativeTargetType = nativeTargetType.GetCanonicalType()
- targetType = self.fromNativeType(nativeTargetType)
- return self.createTypedefedType(targetType, nativeType.GetName(),
- self.nativeTypeId(nativeType))
-
- nativeType = nativeType.GetUnqualifiedType()
- typeName = self.typeName(nativeType)
+ target_typeid = self.from_native_type(nativeTargetType)
+ typeid = self.create_typedefed_typeid(target_typeid, nativeType.GetName(),
+ typeid_str)
- if code in (lldb.eTypeClassArray, lldb.eTypeClassVector):
+ elif code in (lldb.eTypeClassArray, lldb.eTypeClassVector):
+ nativeType = nativeType.GetUnqualifiedType()
+ type_name = nativeType.GetName()
#DumperBase.warn('ARRAY: %s' % nativeType.GetName())
if hasattr(nativeType, 'GetArrayElementType'): # New in 3.8(?) / 350.x
nativeTargetType = nativeType.GetArrayElementType()
@@ -412,141 +408,139 @@ class Dumper(DumperBase):
#DumperBase.warn('BAD: %s ' % nativeTargetType.get_fields_array())
nativeTargetType = nativeType.GetVectorElementType()
count = nativeType.GetByteSize() // nativeTargetType.GetByteSize()
- targetTypeName = nativeTargetType.GetName()
- if targetTypeName.startswith('(anon'):
- typeName = nativeType.GetName()
- pos1 = typeName.rfind('[')
- targetTypeName = typeName[0:pos1].strip()
- #DumperBase.warn("TARGET TYPENAME: %s" % targetTypeName)
- targetType = self.fromNativeType(nativeTargetType)
- targetType.setTdata(targetType.tdata.copy())
- targetType.tdata.name = targetTypeName
- return self.createArrayType(targetType, count)
- if hasattr(nativeType, 'GetVectorElementType'): # New in 3.8(?) / 350.x
+ target_typename = nativeTargetType.GetName()
+ if target_typename.startswith('(anon'):
+ type_name = nativeType.GetName()
+ pos1 = type_name.rfind('[')
+ target_typename = type_name[0:pos1].strip()
+ #DumperBase.warn("TARGET TYPENAME: %s" % target_typename)
+ target_typeid = self.from_native_type(nativeTargetType)
+ #target_typeid.setTdata(target_typeid.tdata.copy())
+ #target_typeid.tdata.name = target_typename
+ typeid = self.create_array_typeid(target_typeid, count)
+ elif hasattr(nativeType, 'GetVectorElementType'): # New in 3.8(?) / 350.x
nativeTargetType = nativeType.GetVectorElementType()
count = nativeType.GetByteSize() // nativeTargetType.GetByteSize()
- targetType = self.fromNativeType(nativeTargetType)
- return self.createArrayType(targetType, count)
- return self.createType(nativeType.GetName())
+ target_typeid = self.from_native_type(nativeTargetType)
+ typeid = self.create_array_typeid(target_typeid, count)
+ else:
+ typeid = self.create_type(nativeType.GetName())
+
+ else:
+ nativeType = nativeType.GetUnqualifiedType()
+ type_name = nativeType.GetName()
- typeId = self.nativeTypeId(nativeType)
- res = self.typeData.get(typeId, None)
- if res is None:
+ typeid = self.typeid_for_string(typeid_str)
+ #if not typeid in self.typeid_cache:
# # This strips typedefs for pointers. We don't want that.
# typeobj.nativeType = nativeType.GetUnqualifiedType()
- tdata = self.TypeData(self, typeId)
- tdata.name = typeName
- tdata.lbitsize = nativeType.GetByteSize() * 8
+ self.type_name_cache[typeid] = type_name
+ self.type_size_cache[typeid] = nativeType.GetByteSize()
+ type_code = None
if code == lldb.eTypeClassBuiltin:
- if utils.isFloatingPointTypeName(typeName):
- tdata.code = TypeCode.Float
- elif utils.isIntegralTypeName(typeName):
- tdata.code = TypeCode.Integral
- elif typeName in ('__int128', 'unsigned __int128'):
- tdata.code = TypeCode.Integral
- elif typeName == 'void':
- tdata.code = TypeCode.Void
- elif typeName == 'wchar_t':
- tdata.code = TypeCode.Integral
- elif typeName in ("char16_t", "char32_t", "char8_t"):
- tdata.code = TypeCode.Integral
+ if utils.isFloatingPointTypeName(type_name):
+ type_code = TypeCode.Float
+ elif utils.isIntegralTypeName(type_name):
+ type_code = TypeCode.Integral
+ elif type_name in ('__int128', 'unsigned __int128'):
+ type_code = TypeCode.Integral
+ elif type_name == 'void':
+ type_code = TypeCode.Void
+ elif type_name == 'wchar_t':
+ type_code = TypeCode.Integral
+ elif type_name in ("char16_t", "char32_t", "char8_t"):
+ type_code = TypeCode.Integral
else:
- self.warn('UNKNOWN TYPE KEY: %s: %s' % (typeName, code))
+ self.warn('UNKNOWN TYPE KEY: %s: %s' % (type_name, code))
elif code == lldb.eTypeClassEnumeration:
- tdata.code = TypeCode.Enum
- tdata.enumDisplay = lambda intval, addr, form: \
+ type_code = TypeCode.Enum
+ self.type_enum_display_cache[typeid] = lambda intval, addr, form: \
self.nativeTypeEnumDisplay(nativeType, intval, form)
elif code in (lldb.eTypeClassComplexInteger, lldb.eTypeClassComplexFloat):
- tdata.code = TypeCode.Complex
+ type_code = TypeCode.Complex
elif code in (lldb.eTypeClassClass, lldb.eTypeClassStruct, lldb.eTypeClassUnion):
- tdata.code = TypeCode.Struct
- tdata.lalignment = lambda: \
- self.nativeStructAlignment(nativeType)
- tdata.lfields = lambda value: \
- self.listMembers(value, nativeType)
- tdata.templateArguments = lambda: \
- self.listTemplateParametersHelper(nativeType)
+ type_code = TypeCode.Struct
elif code == lldb.eTypeClassFunction:
- tdata.code = TypeCode.Function
+ type_code = TypeCode.Function
elif code == lldb.eTypeClassMemberPointer:
- tdata.code = TypeCode.MemberPointer
- # warn('CREATE TYPE: %s' % typeId)
+ type_code = TypeCode.MemberPointer
+
+ if code is not None:
+ self.type_code_cache[typeid] = type_code
+
+ self.type_nativetype_cache[typeid] = nativeType
+ self.typeid_from_typekey[typeid_str] = typeid
+
+ # self.warn('REUSE TYPE: %s' % typeid)
+ return typeid
+
+ def nativeTemplateParameter(self, typeid, index, nativeType):
+ #n = nativeType.GetNumberOfTemplateArguments()
+ #if n != len(stringArgs):
+ # # Something wrong in the debug info.
+ # # Should work in theory, doesn't work in practice.
+ # # Items like std::allocator<std::pair<unsigned int const, float> report 0
+ # # for nativeType.GetNumberOfTemplateArguments() with LLDB 3.8
+ # return stringArgs
+
+ kind = nativeType.GetTemplateArgumentKind(index)
+ # eTemplateArgumentKindNull = 0,
+ # eTemplateArgumentKindType,
+ # eTemplateArgumentKindDeclaration,
+ # eTemplateArgumentKindIntegral,
+ # eTemplateArgumentKindTemplate,
+ # eTemplateArgumentKindTemplateExpansion,
+ # eTemplateArgumentKindExpression,
+ # eTemplateArgumentKindPack
+ if kind == lldb.eTemplateArgumentKindType:
+ innerType = nativeType.GetTemplateArgumentType(index) \
+ .GetUnqualifiedType().GetCanonicalType()
+ return self.Type(self, self.from_native_type(innerType))
+ #elif kind == lldb.eTemplateArgumentKindIntegral:
+ # innerType = nativeType.GetTemplateArgumentType(i).GetUnqualifiedType().GetCanonicalType()
+ # #DumperBase.warn('INNER TYP: %s' % innerType)
+ # basicType = innerType.GetBasicType()
+ # #DumperBase.warn('IBASIC TYP: %s' % basicType)
+ # inner = self.extractTemplateArgument(nativeType.GetName(), i)
+ # exp = '(%s)%s' % (innerType.GetName(), inner)
+ # #DumperBase.warn('EXP : %s' % exp)
+ # val = self.nativeParseAndEvaluate('(%s)%s' % (innerType.GetName(), inner))
+ # # Clang writes 'int' and '0xfffffff' into the debug info
+ # # LLDB manages to read a value of 0xfffffff...
+ # #if basicType == lldb.eBasicTypeInt:
+ # value = val.GetValueAsUnsigned()
+ # if value >= 0x8000000:
+ # value -= 0x100000000
+ # #DumperBase.warn('KIND: %s' % kind)
+ # targs.append(value)
#else:
- # warn('REUSE TYPE: %s' % typeId)
- return self.Type(self, typeId)
-
- def listTemplateParametersHelper(self, nativeType):
- stringArgs = self.listTemplateParameters(nativeType.GetName())
- n = nativeType.GetNumberOfTemplateArguments()
- if n != len(stringArgs):
- # Something wrong in the debug info.
- # Should work in theory, doesn't work in practice.
- # Items like std::allocator<std::pair<unsigned int const, float> report 0
- # for nativeType.GetNumberOfTemplateArguments() with LLDB 3.8
- return stringArgs
-
- targs = []
- for i in range(nativeType.GetNumberOfTemplateArguments()):
- kind = nativeType.GetTemplateArgumentKind(i)
- # eTemplateArgumentKindNull = 0,
- # eTemplateArgumentKindType,
- # eTemplateArgumentKindDeclaration,
- # eTemplateArgumentKindIntegral,
- # eTemplateArgumentKindTemplate,
- # eTemplateArgumentKindTemplateExpansion,
- # eTemplateArgumentKindExpression,
- # eTemplateArgumentKindPack
- if kind == lldb.eTemplateArgumentKindType:
- innerType = nativeType.GetTemplateArgumentType(
- i).GetUnqualifiedType().GetCanonicalType()
- targs.append(self.fromNativeType(innerType))
- #elif kind == lldb.eTemplateArgumentKindIntegral:
- # innerType = nativeType.GetTemplateArgumentType(i).GetUnqualifiedType().GetCanonicalType()
- # #DumperBase.warn('INNER TYP: %s' % innerType)
- # basicType = innerType.GetBasicType()
- # #DumperBase.warn('IBASIC TYP: %s' % basicType)
- # inner = self.extractTemplateArgument(nativeType.GetName(), i)
- # exp = '(%s)%s' % (innerType.GetName(), inner)
- # #DumperBase.warn('EXP : %s' % exp)
- # val = self.nativeParseAndEvaluate('(%s)%s' % (innerType.GetName(), inner))
- # # Clang writes 'int' and '0xfffffff' into the debug info
- # # LLDB manages to read a value of 0xfffffff...
- # #if basicType == lldb.eBasicTypeInt:
- # value = val.GetValueAsUnsigned()
- # if value >= 0x8000000:
- # value -= 0x100000000
- # #DumperBase.warn('KIND: %s' % kind)
- # targs.append(value)
- else:
- #DumperBase.warn('UNHANDLED TEMPLATE TYPE : %s' % kind)
- targs.append(stringArgs[i]) # Best we can do.
+ # #DumperBase.warn('UNHANDLED TEMPLATE TYPE : %s' % kind)
+ # targs.append(stringArgs[i]) # Best we can do.
#DumperBase.warn('TARGS: %s %s' % (nativeType.GetName(), [str(x) for x in targs]))
- return targs
-
- def typeName(self, nativeType):
- # Don't use GetDisplayTypeName since LLDB removed the inline namespace __1
- # https://reviews.llvm.org/D74478
- return nativeType.GetName()
+ #return targs
+ return None
- def nativeTypeId(self, nativeType):
- if nativeType and (nativeType.GetTypeClass() == lldb.eTypeClassTypedef):
+ def native_type_key(self, nativeType):
+ code = nativeType.GetTypeClass()
+ if nativeType and code == lldb.eTypeClassTypedef:
nativeTargetType = nativeType.GetUnqualifiedType()
if hasattr(nativeTargetType, 'GetCanonicalType'):
nativeTargetType = nativeTargetType.GetCanonicalType()
return '%s{%s}' % (nativeType.name, nativeTargetType.name)
- name = self.typeName(nativeType)
+ # Don't use GetDisplayTypeName since LLDB removed the inline namespace __1
+ # https://reviews.llvm.org/D74478
+ name = nativeType.GetName()
if name is None or len(name) == 0:
c = '0'
- elif name == '(anonymous struct)' and nativeType.GetTypeClass() == lldb.eTypeClassStruct:
- c = 's'
- elif name == '(anonymous struct)' and nativeType.GetTypeClass() == lldb.eTypeClassUnion:
- c = 'u'
+ elif name == '(anonymous struct)':
+ c = 's' if code == lldb.eTypeClassStruct else 'u'
else:
return name
fields = nativeType.get_fields_array()
- typeId = c + ''.join(['{%s:%s}' % (f.name, self.nativeTypeId(f.GetType())) for f in fields])
- #DumperBase.warn('NATIVE TYPE ID FOR %s IS %s' % (name, typeId))
- return typeId
+ id_str = c + ''.join(['{%s:%s}' %
+ (f.name, self.typeid_for_string(self.native_type_key(f.GetType())))
+ for f in fields])
+ return id_str
def nativeTypeEnumDisplay(self, nativeType, intval, form):
if hasattr(nativeType, 'get_enum_members_array'):
@@ -575,12 +569,82 @@ class Dumper(DumperBase):
return '(' + ' | '.join(flags) + ') (' + (form % intval) + ')'
return form % intval
- def nativeDynamicTypeName(self, address, baseType):
- return None # FIXME: Seems sufficient, no idea why.
- addr = self.target.ResolveLoadAddress(address)
- ctx = self.target.ResolveSymbolContextForAddress(addr, 0)
- sym = ctx.GetSymbol()
- return sym.GetName()
+ def nativeDynamicType(self, address, base_typeid):
+ return self.nativeDynamicType_2(address, base_typeid)
+
+ def nativeDynamicType_1(self, address, base_typeid):
+ # Solutions 1: Breaks StdUniquePtr and QVariant1 test
+ return base_typeid
+
+ def nativeDynamicType_2(self, address, base_typeid):
+ # Solution 2: ~10% slower in total than Solution 1
+ typename = self.type_name(base_typeid)
+ #self.warn("LOOKING FOR DYN TYPE: 0x%x %s" % (address, typename))
+ #self.warn(" PRETTY: 0x%x %s" % (address, self.prettySymbolByAddress(address)))
+
+ expr = '(void*)%s' % address
+ value = self.target.EvaluateExpression(expr)
+
+ #self.warn("VALUE: %s" % value)
+ if value.GetType().GetName() == "void *":
+ #self.warn("NO DYN TYPE: %s" % value)
+ return base_typeid
+
+ dvalue = value.Dereference()
+ #self.warn("DVALUE: %s" % value)
+ sbtype = dvalue.GetType()
+ #self.warn("TYPE: %s" % sbtype)
+
+ #self.warn("OUTPUT: %s" % output)
+ #self.warn("DYNTYPE: %s" % dyn_typename)
+ return self.from_native_type(sbtype)
+
+ def nativeDynamicType_3(self, address, base_typeid):
+ # Solution 3: Doesn't improve over 1
+ typename = self.type_name(base_typeid)
+ self.warn("LOOKING FOR DYN TYPE: 0x%x %s" % (address, typename))
+ #self.warn(" PRETTY: 0x%x %s" % (address, self.prettySymbolByAddress(address)))
+ nativeType = self.type_nativetype_cache.get(base_typeid, None)
+ #self.warn(" NATIVE BASE %s" % nativeType)
+ if nativeType is None:
+ return base_typeid
+ #versionValue = self.target.EvaluateExpression('qtHookData[2]').GetNonSyntheticValue()
+ addr = lldb.SBAddress(address, self.target)
+ value = self.target.CreateValueFromAddress('x', addr, nativeType)
+ self.warn(" VALUE %s" % value)
+ return base_typeid
+
+ def nativeDynamicType_4(self, address, base_typeid):
+ #self.warn("RESULT: %s" % result)
+ #self.warn("ADDRESS: 0x%x" % address)
+
+ #thread = self.currentThread()
+ #frame = thread.GetFrameAtIndex(0)
+ #expr = '(void*)%s' % address
+ #value = self.target.EvaluateExpression(expr)
+ #sbtype = self.lookupNativeType(typename)
+ #addr = self.target.ResolveLoadAddress(address)
+ #addr = lldb.SBAddress(address, self.target)
+ #value = self.target.CreateValueFromAddress('x', addr, sbtype)
+ #x = lldb::DynamicValueType()
+ #lldb.eNoDynamicValues
+ #lldb.eDynamicCanRunTarget
+ #lldb.eDynamicDontRunTarget
+ #dyn_value = value.GetDynamicValue(lldb.eDynamicDontRunTarget)
+ #typ = dyn_value.GetType()
+ self.warn("GOT DYN VALUE: %s" % dyn_value)
+ #self.warn("GOT TYPE: %s FOR OBJECT AT 0x%x" % (typ, address))
+ return self.from_native_type(typ)
+
+ #result = lldb.SBCommandReturnObject()
+ #cmd = 'p (void*)%s' % address
+ #self.debugger.GetCommandInterpreter().HandleCommand(cmd, result)
+ #if not result.Succeeded():
+ # return self.Type(self, typeid)
+ #output = result.GetOutput().strip()
+ #dyn_typename = output[1:output.find('$') - 4]
+ #sbtype = self.lookupNativeType(dyn_typename)
+
def stateName(self, s):
try:
@@ -638,11 +702,11 @@ class Dumper(DumperBase):
#DumperBase.warn(' -> %s' % result)
return self.fromNativeValue(result)
- def pokeValue(self, typeName, *args):
+ def pokeValue(self, type_name, *args):
thread = self.currentThread()
frame = thread.GetFrameAtIndex(0)
inner = ','.join(args)
- value = frame.EvaluateExpression(typeName + '{' + inner + '}')
+ value = frame.EvaluateExpression(type_name + '{' + inner + '}')
#DumperBase.warn(' TYPE: %s' % value.type)
#DumperBase.warn(' ADDR: 0x%x' % value.address)
#DumperBase.warn(' VALUE: %s' % value)
@@ -830,8 +894,6 @@ class Dumper(DumperBase):
#DumperBase.warn('RECURSE PTR')
typeobj = self.lookupNativeType(name[:-1].strip())
if typeobj is not None:
- #DumperBase.warn('RECURSE RESULT X: %s' % typeobj)
- self.fromNativeType(typeobj.GetPointerType())
#DumperBase.warn('RECURSE RESULT: %s' % typeobj.GetPointerType())
return typeobj.GetPointerType()
@@ -1289,14 +1351,12 @@ class Dumper(DumperBase):
def findSymbol(self, symbolName):
return self.target.FindFirstGlobalVariable(symbolName)
- def warn(self, msg):
- self.put('{name="%s",value="",type="",numchild="0"},' % toCString(msg))
-
def fetchVariables(self, args):
- (ok, res) = self.tryFetchInterpreterVariables(args)
- if ok:
- self.reportResult(res, args)
- return
+ start_time = time.perf_counter()
+ #(ok, res) = self.tryFetchInterpreterVariables(args)
+ #if ok:
+ # self.reportResult(res, args)
+ # return
self.setVariableFetchingOptions(args)
@@ -1360,13 +1420,15 @@ class Dumper(DumperBase):
# This can happen for unnamed function parameters with
# default values: void foo(int = 0)
continue
- value = self.fromNativeFrameValue(val)
+ value = self.fromNativeValue(val)
variables.append(value)
self.handleLocals(variables)
self.handleWatches(args)
- self.put('],partial="%d"' % isPartial)
+ run_time = time.perf_counter() - start_time
+
+ self.put('],partial="%d",runtime="%s"' % (isPartial, run_time))
self.reportResult(self.takeOutput(), args)
@@ -1987,14 +2049,14 @@ class Dumper(DumperBase):
value = self.hexdecode(args['value'])
simpleType = int(args['simpleType'])
lhs = self.findValueByExpression(expr)
- typeName = lhs.GetType().GetName()
- typeName = typeName.replace('::', '__')
- pos = typeName.find('<')
+ type_name = lhs.GetType().GetName()
+ type_name = type_name.replace('::', '__')
+ pos = type_name.find('<')
if pos != -1:
- typeName = typeName[0:pos]
- if typeName in self.qqEditable and not simpleType:
+ type_name = type_name[0:pos]
+ if type_name in self.qqEditable and not simpleType:
expr = self.parseAndEvaluate(expr)
- self.qqEditable[typeName](self, expr, value)
+ self.qqEditable[type_name](self, expr, value)
else:
self.parseAndEvaluate(expr + '=' + value)
self.reportResult(self.describeError(error), args)
@@ -2098,10 +2160,10 @@ class Tester(Dumper):
if 'QT_CREATOR_LLDB_PROCESS' in os.environ:
# Initialize Qt Creator dumper
- try:
+ #try:
theDumper = Dumper()
- except Exception as error:
- print('@\nstate="enginesetupfailed",error="{}"@\n'.format(error))
+ #except Exception as error:
+ # print('@\nstate="enginesetupfailed",error="{}"@\n'.format(error))
# ------------------------------ For use in LLDB ------------------------------
diff --git a/share/qtcreator/debugger/qttypes.py b/share/qtcreator/debugger/qttypes.py
index 06e7d47325..af99534c9b 100644
--- a/share/qtcreator/debugger/qttypes.py
+++ b/share/qtcreator/debugger/qttypes.py
@@ -221,15 +221,15 @@ def qdump__Qt__ItemDataRole(d, value):
def qdump__QStandardItemData(d, value):
- d.createType('@Qt::ItemDataRole') # warm up cache
+ #d.createType('@Qt::ItemDataRole') # warm up cache
role, pad, val = value.split('{@Qt::ItemDataRole}@{@QVariant}')
d.putPairContents(role.value(), (role, val), 'role', 'value')
def qdump__QStandardItem(d, value):
- d.createType('@QStandardItemData') # warm up cache
- d.createType('@QStandardItem')
- d.createType('@QStandardItem*')
+ #d.createType('@QStandardItemData') # warm up cache
+ #d.createType('@QStandardItem')
+ #d.createType('@QStandardItem*')
vtable, dptr = value.split('pp')
if d.qtVersion() >= 0x060000:
@@ -549,14 +549,11 @@ def qdump__QDir(d, value):
#d.putCallItem('absolutePath', '@QString', value, 'absolutePath')
#d.putCallItem('canonicalPath', '@QString', value, 'canonicalPath')
with SubItem(d, 'absolutePath'):
- typ = d.lookupType(ns + 'QString')
- d.putItem(d.createValue(privAddress + absoluteDirEntryOffset, typ))
+ d.putItem(d.createValue(privAddress + absoluteDirEntryOffset, '@QString'))
with SubItem(d, 'entryInfoList'):
- typ = d.lookupType(ns + 'QFileInfo')
- qdumpHelper_QList(d, privAddress + fileInfosOffset, typ)
+ qdumpHelper_QList(d, privAddress + fileInfosOffset, '@QFileInfo')
with SubItem(d, 'entryList'):
- typ = d.lookupType(ns + 'QStringList')
- d.putItem(d.createValue(privAddress + filesOffset, typ))
+ d.putItem(d.createValue(privAddress + filesOffset, '@QStringList'))
d.putFields(value)
@@ -1095,14 +1092,15 @@ def qform__QList():
def qdump__QList(d, value):
- return qdumpHelper_QList(d, value, d.createType(value.type[0]))
+ return qdumpHelper_QList(d, value, value.type[0])
def qdump__QVariantList(d, value):
- qdumpHelper_QList(d, value, d.createType('@QVariant'))
+ qdumpHelper_QList(d, value, '@QVariant')
-def qdumpHelper_QList(d, value, innerType):
+def qdumpHelper_QList(d, value, inner_typish):
+ innerType = d.createType(inner_typish)
data, size = d.listData(value, check=True)
d.putItemCount(size)
@@ -1224,7 +1222,8 @@ def qdump__QLocale(d, value):
# index = int(value['d']['d']['m_data']...)
#d.check(index >= 0)
#d.check(index <= qqLocalesCount)
- if d.qtVersion() < 0x50000:
+ qtVersion = d.qtVersion()
+ if qtVersion < 0x50000:
d.putStringValue(d.call('const char *', value, 'name'))
d.putPlainChildren(value)
return
@@ -1238,14 +1237,20 @@ def qdump__QLocale(d, value):
= d.split('2s{short}2s'
+ '{@QChar}{@QChar}{short}{@QChar}{@QChar}'
+ '{@QChar}{@QChar}{@QChar}', data)
+
+ prefix = ns + 'QLocale::'
try:
- d.putStringValue(d.call('const char *', value, 'name'))
+ if qtVersion >= 0x060700:
+ res = d.call('const char *', value, 'name', prefix + 'TagSeparator::Underscore')
+ else:
+ res = d.call('const char *', value, 'name')
+ d.putStringValue(res)
except:
pass
+
d.putExpandable()
if d.isExpanded():
with Children(d):
- prefix = ns + 'QLocale::'
d.putSubItem('country', d.createValue(countryId, prefix + 'Country'))
d.putSubItem('language', d.createValue(languageId, prefix + 'Language'))
d.putSubItem('numberOptions', d.createValue(numberOptions, prefix + 'NumberOptions'))
@@ -1425,7 +1430,9 @@ if False:
d.putSpecialValue('minimumitemcount', 0)
-def qdump__QPair(d, value):
+# FIXME: Qt 5
+# remvign the _xxxx makes GDB work with Qt 5 but breaks LLDB
+def qdump__QPair_xxxx(d, value):
typeCode = '{%s}@{%s}' % (value.type[0].name, value.type[1].name)
first, pad, second = value.split(typeCode)
with Children(d):
@@ -1857,7 +1864,7 @@ def qdump__QStringRef(d, value):
def qdump__QStringList(d, value):
- qdumpHelper_QList(d, value, d.createType('@QString'))
+ qdumpHelper_QList(d, value, '@QString')
d.putBetterType(value.type)
@@ -2304,22 +2311,22 @@ def qdump__QVector(d, value):
if d.qtVersion() >= 0x060000:
data, length = d.listData(value)
d.putItemCount(length)
- d.putPlotData(data, length, d.createType(value.type.ltarget[0]))
+ d.putPlotData(data, length, value.type.target()[0])
# g++ 9.3 does not add the template parameter list to the debug info.
# Fake it for the common case:
if value.type.name == d.qtNamespace() + "QVector":
- d.putBetterType(value.type.name + '<' + value.type.ltarget[0].name + '>')
+ d.putBetterType(value.type.name + '<' + value.type.target()[0].name + '>')
else:
data, length = d.vectorData(value)
d.putItemCount(length)
- d.putPlotData(data, length, d.createType(value.type[0]))
+ d.putPlotData(data, length, value.type[0])
if False:
def qdump__QObjectConnectionList(d, value):
data, length = d.vectorData(value)
d.putItemCount(length)
- d.putPlotData(data, length, d.createType('@QObjectPrivate::ConnectionList'))
+ d.putPlotData(data, length, '@QObjectPrivate::ConnectionList')
def qdump__QVarLengthArray(d, value):
@@ -2913,15 +2920,13 @@ def qdump_64__QJSValue_6(d, value):
elif typ > 7:
val = d.Value(d)
val.ldata = struct.pack('q', dd ^ 0xfffc000000000000)
- val._type = d.createType('double')
- d.putItem(val)
+ d.putItem(val.cast('double'))
d.putType(value.type.name + ' (double)')
elif typ <= 3: # Heap
if dd & 1: # String
val = d.Value(d)
val.ldata = struct.pack('q', dd & ~1)
- val._type = d.createType('@QString*')
- d.putItem(val)
+ d.putItem(val.cast('@QString*'))
d.putType(value.type.name + ' (QString)')
else:
# FIXME: Arrays, Objects missing.
@@ -2955,16 +2960,13 @@ def qdump_64__QJSValue_6(d, value):
val = d.Value(d)
val.ldata = struct.pack('q', pointer)
if typ == 1:
- val._type = d.createType('double*')
- d.putItem(val)
+ d.putItem(val.cast('double*'))
d.putType(value.type.name + ' (double)')
elif typ == 3:
- val._type = d.createType('@QV4::Value*')
- d.putItem(val)
+ d.putItem(val.cast('@QV4::Value*'))
d.putType(value.type.name + ' (QV4::Value)')
elif typ == 5:
- val._type = d.createType('@QString*')
- d.putItem(val)
+ d.putItem(val.cast('@QString*'))
d.putType(value.type.name + ' (QString)')
else:
@@ -3538,7 +3540,7 @@ def qdump__QCborValue(d, value):
d.putPlainChildren(value)
def qdump__QCborValue_proxy(d, value):
- item_data, container_ptr, item_type, is_cbor = value.data()
+ item_data, container_ptr, item_type, is_cbor = value.ldata
def typename(key, is_cbor):
if is_cbor:
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-17 16:45:40 +0000