feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Dumper: move global enums and functions to utils

Browse Source 
Change-Id: I11f5f0d970cd23a5fd907d33daa3cb8a441d0c58
Reviewed-by: hjk <hjk@qt.io>
This commit is contained in:
David Schulz
2020-02-21 10:10:00 +01:00
parent b2ceb7db79
commit e17c96cf11
11 changed files with 636 additions and 602 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
share/qtcreator/debugger/cdbbridge.py
View File

@@ -28,6 +28,7 @@ import os
import sys
import cdbext
import re
from utils import TypeCode
sys.path.insert(1, os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))))
@@ -47,19 +48,19 @@ class FakeVoidType(cdbext.Type):
def code(self):
if self.typeName.endswith('*'):
return TypeCodePointer
return TypeCode.TypeCodePointer
if self.typeName.endswith(']'):
return TypeCodeArray
return TypeCodeVoid
return TypeCode.TypeCodeArray
return TypeCode.TypeCodeVoid
def unqualified(self):
return self
def target(self):
code = self.code()
if code == TypeCodePointer:
if code == TypeCode.TypeCodePointer:
return FakeVoidType(self.typeName[:-1], self.dumper)
if code == TypeCodeVoid:
if code == TypeCode.TypeCodeVoid:
return self
try:
return FakeVoidType(self.typeName[:self.typeName.rindex('[')], self.dumper)
@@ -105,7 +106,7 @@ class Dumper(DumperBase):
val.type = self.fromNativeType(nativeValue.type())
# There is no cdb api for the size of bitfields.
# Workaround this issue by parsing the native debugger text for integral types.
if val.type.code == TypeCodeIntegral:
if val.type.code == TypeCode.TypeCodeIntegral:
integerString = nativeValue.nativeDebuggerValue()
if integerString == 'true':
val.ldata = int(1).to_bytes(1, byteorder='little')
@@ -128,7 +129,7 @@ class Dumper(DumperBase):
except:
# read raw memory in case the integerString can not be interpreted
pass
if val.type.code == TypeCodeEnum:
if val.type.code == TypeCode.TypeCodeEnum:
val.ldisplay = self.enumValue(nativeValue)
val.isBaseClass = val.name == val.type.name
val.nativeValue = nativeValue
@@ -159,21 +160,21 @@ class Dumper(DumperBase):
nativeType = FakeVoidType(nativeType.name(), self)
code = nativeType.code()
if code == TypeCodePointer:
if code == TypeCode.TypeCodePointer:
if not nativeType.name().startswith('<function>'):
targetType = self.lookupType(nativeType.targetName(), nativeType.moduleId())
if targetType is not None:
return self.createPointerType(targetType)
code = TypeCodeFunction
code = TypeCode.TypeCodeFunction
if code == TypeCodeArray:
if code == TypeCode.TypeCodeArray:
# 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 '):
targetType = self.lookupType(nativeType.targetName(), nativeType.moduleId())
if targetType is not None:
return self.createArrayType(targetType, nativeType.arrayElements())
code = TypeCodeStruct
code = TypeCode.TypeCodeStruct
tdata = self.TypeData(self)
tdata.name = nativeType.name()
@@ -182,12 +183,12 @@ class Dumper(DumperBase):
tdata.code = code
tdata.moduleName = nativeType.module()
self.registerType(typeId, tdata) # Prevent recursion in fields.
if code == TypeCodeStruct:
if code == TypeCode.TypeCodeStruct:
tdata.lfields = lambda value : \
self.listFields(nativeType, value)
tdata.lalignment = lambda : \
self.nativeStructAlignment(nativeType)
if code == TypeCodeEnum:
if code == TypeCode.TypeCodeEnum:
tdata.enumDisplay = lambda intval, addr, form : \
self.nativeTypeEnumDisplay(nativeType, intval, form)
tdata.templateArguments = self.listTemplateParameters(nativeType.name())
@@ -206,7 +207,7 @@ class Dumper(DumperBase):
nativeMember = nativeValue.childFromIndex(index)
def nativeStructAlignment(self, nativeType):
#warn("NATIVE ALIGN FOR %s" % nativeType.name)
#DumperBase.warn("NATIVE ALIGN FOR %s" % nativeType.name)
def handleItem(nativeFieldType, align):
a = self.fromNativeType(nativeFieldType).alignment()
return a if a > align else align

2
share/qtcreator/debugger/creatortypes.py
View File

@@ -234,7 +234,7 @@ def qdump__CPlusPlus__Internal__PPToken(d, value):
data, size, alloc = d.byteArrayData(value["m_src"])
length = value["f"]["utf16chars"].integer()
offset = value["utf16charOffset"].integer()
#warn("size: %s, alloc: %s, offset: %s, length: %s, data: %s"
#DumperBase.warn("size: %s, alloc: %s, offset: %s, length: %s, data: %s"
# % (size, alloc, offset, length, data))
d.putValue(d.readMemory(data + offset, min(100, length)), "latin1")
d.putPlainChildren(value)

623
share/qtcreator/debugger/dumper.py
View File

File diff suppressed because it is too large Load Diff

146
share/qtcreator/debugger/gdbbridge.py
View File

@@ -38,7 +38,7 @@ import tempfile
import types
from dumper import *
from utils import TypeCode
#######################################################################
#
@@ -168,7 +168,7 @@ def importPlainDumpers(args):
gdb.execute('disable pretty-printer .* .*')
except:
# Might occur in non-ASCII directories
warn('COULD NOT DISABLE PRETTY PRINTERS')
DumperBase.warn('COULD NOT DISABLE PRETTY PRINTERS')
else:
theDumper.importPlainDumpers()
@@ -186,7 +186,7 @@ class OutputSaver:
def __exit__(self, exType, exValue, exTraceBack):
if self.d.passExceptions and not exType is None:
showException('OUTPUTSAVER', exType, exValue, exTraceBack)
self.d.showException('OUTPUTSAVER', exType, exValue, exTraceBack)
self.d.output = self.savedOutput
else:
self.savedOutput += self.d.output
@@ -217,7 +217,7 @@ class Dumper(DumperBase):
self.setVariableFetchingOptions(args)
def fromFrameValue(self, nativeValue):
#warn('FROM FRAME VALUE: %s' % nativeValue.address)
#DumperBase.warn('FROM FRAME VALUE: %s' % nativeValue.address)
val = nativeValue
try:
val = nativeValue.cast(nativeValue.dynamic_type)
@@ -226,7 +226,7 @@ class Dumper(DumperBase):
return self.fromNativeValue(val)
def fromNativeValue(self, nativeValue):
#warn('FROM NATIVE VALUE: %s' % nativeValue)
#DumperBase.warn('FROM NATIVE VALUE: %s' % nativeValue)
self.check(isinstance(nativeValue, gdb.Value))
nativeType = nativeValue.type
code = nativeType.code
@@ -234,7 +234,7 @@ class Dumper(DumperBase):
targetType = self.fromNativeType(nativeType.target().unqualified())
val = self.createReferenceValue(toInteger(nativeValue.address), targetType)
val.nativeValue = nativeValue
#warn('CREATED REF: %s' % val)
#DumperBase.warn('CREATED REF: %s' % val)
return val
if code == gdb.TYPE_CODE_PTR:
try:
@@ -248,14 +248,14 @@ class Dumper(DumperBase):
# later which
# is surprisingly expensive.
val.nativeValue = nativeValue
#warn('CREATED PTR 1: %s' % val)
#DumperBase.warn('CREATED PTR 1: %s' % val)
if not nativeValue.address is None:
val.laddress = toInteger(nativeValue.address)
#warn('CREATED PTR 2: %s' % val)
#DumperBase.warn('CREATED PTR 2: %s' % val)
return val
if code == gdb.TYPE_CODE_TYPEDEF:
targetType = nativeType.strip_typedefs().unqualified()
#warn('TARGET TYPE: %s' % targetType)
#DumperBase.warn('TARGET TYPE: %s' % targetType)
if targetType.code == gdb.TYPE_CODE_ARRAY:
val = self.Value(self)
else:
@@ -267,7 +267,7 @@ class Dumper(DumperBase):
val = self.fromNativeValue(nativeValue.cast(targetType))
except:
val = self.Value(self)
#warn('CREATED TYPEDEF: %s' % val)
#DumperBase.warn('CREATED TYPEDEF: %s' % val)
else:
val = self.Value(self)
@@ -308,34 +308,34 @@ class Dumper(DumperBase):
def fromNativeType(self, nativeType):
self.check(isinstance(nativeType, gdb.Type))
code = nativeType.code
#warn('FROM NATIVE TYPE: %s' % nativeType)
#DumperBase.warn('FROM NATIVE TYPE: %s' % nativeType)
nativeType = nativeType.unqualified()
if code == gdb.TYPE_CODE_PTR:
#warn('PTR')
#DumperBase.warn('PTR')
targetType = self.fromNativeType(nativeType.target().unqualified())
return self.createPointerType(targetType)
if code == gdb.TYPE_CODE_REF:
#warn('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:
#warn('RVALUEREF')
#DumperBase.warn('RVALUEREF')
targetType = self.fromNativeType(nativeType.target())
return self.createRValueReferenceType(targetType)
if code == gdb.TYPE_CODE_ARRAY:
#warn('ARRAY')
#DumperBase.warn('ARRAY')
nativeTargetType = nativeType.target().unqualified()
targetType = self.fromNativeType(nativeTargetType)
count = nativeType.sizeof // nativeTargetType.sizeof
return self.createArrayType(targetType, count)
if code == gdb.TYPE_CODE_TYPEDEF:
#warn('TYPEDEF')
#DumperBase.warn('TYPEDEF')
nativeTargetType = nativeType.unqualified()
while nativeTargetType.code == gdb.TYPE_CODE_TYPEDEF:
nativeTargetType = nativeTargetType.strip_typedefs().unqualified()
@@ -344,7 +344,7 @@ class Dumper(DumperBase):
self.nativeTypeId(nativeType))
if code == gdb.TYPE_CODE_ERROR:
warn('Type error: %s' % nativeType)
self.warn('Type error: %s' % nativeType)
return self.Type(self, '')
typeId = self.nativeTypeId(nativeType)
@@ -356,28 +356,28 @@ class Dumper(DumperBase):
tdata.lbitsize = nativeType.sizeof * 8
tdata.code = {
#gdb.TYPE_CODE_TYPEDEF : TypeCodeTypedef, # Handled above.
gdb.TYPE_CODE_METHOD : TypeCodeFunction,
gdb.TYPE_CODE_VOID : TypeCodeVoid,
gdb.TYPE_CODE_FUNC : TypeCodeFunction,
gdb.TYPE_CODE_METHODPTR : TypeCodeFunction,
gdb.TYPE_CODE_MEMBERPTR : TypeCodeFunction,
#gdb.TYPE_CODE_PTR : TypeCodePointer, # Handled above.
#gdb.TYPE_CODE_REF : TypeCodeReference, # Handled above.
gdb.TYPE_CODE_BOOL : TypeCodeIntegral,
gdb.TYPE_CODE_CHAR : TypeCodeIntegral,
gdb.TYPE_CODE_INT : TypeCodeIntegral,
gdb.TYPE_CODE_FLT : TypeCodeFloat,
gdb.TYPE_CODE_ENUM : TypeCodeEnum,
#gdb.TYPE_CODE_ARRAY : TypeCodeArray,
gdb.TYPE_CODE_STRUCT : TypeCodeStruct,
gdb.TYPE_CODE_UNION : TypeCodeStruct,
gdb.TYPE_CODE_COMPLEX : TypeCodeComplex,
gdb.TYPE_CODE_STRING : TypeCodeFortranString,
gdb.TYPE_CODE_METHOD : TypeCode.TypeCodeFunction,
gdb.TYPE_CODE_VOID : TypeCode.TypeCodeVoid,
gdb.TYPE_CODE_FUNC : TypeCode.TypeCodeFunction,
gdb.TYPE_CODE_METHODPTR : TypeCode.TypeCodeFunction,
gdb.TYPE_CODE_MEMBERPTR : TypeCode.TypeCodeFunction,
#gdb.TYPE_CODE_PTR : TypeCode.TypeCodePointer, # Handled above.
#gdb.TYPE_CODE_REF : TypeCode.TypeCodeReference, # Handled above.
gdb.TYPE_CODE_BOOL : TypeCode.TypeCodeIntegral,
gdb.TYPE_CODE_CHAR : TypeCode.TypeCodeIntegral,
gdb.TYPE_CODE_INT : TypeCode.TypeCodeIntegral,
gdb.TYPE_CODE_FLT : TypeCode.TypeCodeFloat,
gdb.TYPE_CODE_ENUM : TypeCode.TypeCodeEnum,
#gdb.TYPE_CODE_ARRAY : TypeCode.TypeCodeArray,
gdb.TYPE_CODE_STRUCT : TypeCode.TypeCodeStruct,
gdb.TYPE_CODE_UNION : TypeCode.TypeCodeStruct,
gdb.TYPE_CODE_COMPLEX : TypeCode.TypeCodeComplex,
gdb.TYPE_CODE_STRING : TypeCode.TypeCodeFortranString,
}[code]
if tdata.code == TypeCodeEnum:
if tdata.code == TypeCode.TypeCodeEnum:
tdata.enumDisplay = lambda intval, addr, form : \
self.nativeTypeEnumDisplay(nativeType, intval, form)
if tdata.code == TypeCodeStruct:
if tdata.code == TypeCode.TypeCodeStruct:
tdata.lalignment = lambda : \
self.nativeStructAlignment(nativeType)
tdata.lfields = lambda value : \
@@ -402,7 +402,7 @@ class Dumper(DumperBase):
elif isinstance(targ, gdb.Value):
targs.append(self.fromNativeValue(targ).value())
else:
error('UNKNOWN TEMPLATE PARAMETER')
raise RuntimeError('UNKNOWN TEMPLATE PARAMETER')
pos += 1
targs2 = self.listTemplateParametersManually(str(nativeType))
return targs if len(targs) >= len(targs2) else targs2
@@ -451,7 +451,7 @@ class Dumper(DumperBase):
return typeId
def nativeStructAlignment(self, nativeType):
#warn('NATIVE ALIGN FOR %s' % nativeType.name)
#DumperBase.warn('NATIVE ALIGN FOR %s' % nativeType.name)
def handleItem(nativeFieldType, align):
a = self.fromNativeType(nativeFieldType).alignment()
return a if a > align else align
@@ -507,7 +507,7 @@ class Dumper(DumperBase):
anonNumber = 0
#warn('LISTING FIELDS FOR %s' % nativeType)
#DumperBase.warn('LISTING FIELDS FOR %s' % nativeType)
for nativeField in nativeType.fields():
fieldName = nativeField.name
# Something without a name.
@@ -521,7 +521,7 @@ class Dumper(DumperBase):
# multiple anonymous unions in the struct.
anonNumber += 1
fieldName = '#%s' % anonNumber
#warn('FIELD: %s' % fieldName)
#DumperBase.warn('FIELD: %s' % fieldName)
# hasattr(nativeField, 'bitpos') == False indicates a static field,
# but if we have access to a nativeValue .fromNativeField will
# also succeed. We essentially skip only static members from
@@ -531,8 +531,8 @@ class Dumper(DumperBase):
def fromNativeField(self, nativeField, nativeValue, fieldName):
nativeFieldType = nativeField.type.unqualified()
#warn(' TYPE: %s' % nativeFieldType)
#warn(' TYPEID: %s' % self.nativeTypeId(nativeFieldType))
#DumperBase.warn(' TYPE: %s' % nativeFieldType)
#DumperBase.warn(' TYPEID: %s' % self.nativeTypeId(nativeFieldType))
if hasattr(nativeField, 'bitpos'):
bitpos = nativeField.bitpos
@@ -562,7 +562,7 @@ class Dumper(DumperBase):
capturedFieldName,
value)
#warn("FOUND NATIVE FIELD: %s bitpos: %s" % (fieldName, bitpos))
#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)
@@ -574,19 +574,19 @@ class Dumper(DumperBase):
try:
block = frame.block()
#warn('BLOCK: %s ' % block)
#DumperBase.warn('BLOCK: %s ' % block)
except RuntimeError as error:
#warn('BLOCK IN FRAME NOT ACCESSIBLE: %s' % error)
#DumperBase.warn('BLOCK IN FRAME NOT ACCESSIBLE: %s' % error)
return []
except:
warn('BLOCK NOT ACCESSIBLE FOR UNKNOWN REASONS')
self.warn('BLOCK NOT ACCESSIBLE FOR UNKNOWN REASONS')
return []
items = []
shadowed = {}
while True:
if block is None:
warn("UNEXPECTED 'None' BLOCK")
self.warn("UNEXPECTED 'None' BLOCK")
break
for symbol in block:
@@ -602,12 +602,12 @@ class Dumper(DumperBase):
# 'NotImplementedError: Symbol type not yet supported in
# Python scripts.'
#warn('SYMBOL %s (%s, %s)): ' % (symbol, name, symbol.name))
#DumperBase.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
#warn('READ 0: %s' % value.stringify())
#DumperBase.warn('READ 0: %s' % value.stringify())
items.append(value)
continue
@@ -616,14 +616,14 @@ class Dumper(DumperBase):
nativeValue = frame.read_var(name, block)
value = self.fromFrameValue(nativeValue)
value.name = name
#warn('READ 1: %s' % value.stringify())
#DumperBase.warn('READ 1: %s' % value.stringify())
items.append(value)
continue
except:
pass
try:
#warn('READ 2: %s' % item.value)
#DumperBase.warn('READ 2: %s' % item.value)
value = self.fromFrameValue(frame.read_var(name))
value.name = name
items.append(value)
@@ -637,8 +637,8 @@ class Dumper(DumperBase):
pass
try:
#warn('READ 3: %s %s' % (name, item.value))
#warn('ITEM 3: %s' % item.value)
#DumperBase.warn('READ 3: %s %s' % (name, item.value))
#DumperBase.warn('ITEM 3: %s' % item.value)
value = self.fromFrameValue(gdb.parse_and_eval(name))
value.name = name
items.append(value)
@@ -685,7 +685,7 @@ class Dumper(DumperBase):
partialName = partialVar.split('.')[1].split('@')[0] if isPartial else None
variables = self.listLocals(partialName)
#warn('VARIABLES: %s' % variables)
#DumperBase.warn('VARIABLES: %s' % variables)
# Take care of the return value of the last function call.
if len(self.resultVarName) > 0:
@@ -728,13 +728,13 @@ class Dumper(DumperBase):
return None if val is None else self.fromNativeValue(val)
def nativeParseAndEvaluate(self, exp):
#warn('EVALUATE "%s"' % exp)
#DumperBase.warn('EVALUATE "%s"' % exp)
try:
val = gdb.parse_and_eval(exp)
return val
except RuntimeError as error:
if self.passExceptions:
warn("Cannot evaluate '%s': %s" % (exp, error))
self.warn("Cannot evaluate '%s': %s" % (exp, error))
return None
def callHelper(self, rettype, value, function, args):
@@ -749,7 +749,7 @@ class Dumper(DumperBase):
else:
arg += a
#warn('CALL: %s -> %s(%s)' % (value, function, arg))
#DumperBase.warn('CALL: %s -> %s(%s)' % (value, function, arg))
typeName = value.type.name
if typeName.find(':') >= 0:
typeName = "'" + typeName + "'"
@@ -758,11 +758,11 @@ class Dumper(DumperBase):
addr = value.address()
if addr is None:
addr = self.pokeValue(value)
#warn('PTR: %s -> %s(%s)' % (value, function, addr))
#DumperBase.warn('PTR: %s -> %s(%s)' % (value, function, addr))
exp = '((%s*)0x%x)->%s(%s)' % (typeName, addr, function, arg)
#warn('CALL: %s' % exp)
#DumperBase.warn('CALL: %s' % exp)
result = gdb.parse_and_eval(exp)
#warn(' -> %s' % result)
#DumperBase.warn(' -> %s' % result)
res = self.fromNativeValue(result)
if value.address() is None:
self.releaseValue(addr)
@@ -770,9 +770,9 @@ class Dumper(DumperBase):
def makeExpression(self, value):
typename = '::' + value.type.name
#warn(' TYPE: %s' % typename)
#DumperBase.warn(' TYPE: %s' % typename)
exp = '(*(%s*)(0x%x))' % (typename, value.address())
#warn(' EXP: %s' % exp)
#DumperBase.warn(' EXP: %s' % exp)
return exp
def makeStdString(init):
@@ -790,13 +790,13 @@ class Dumper(DumperBase):
size = value.type.size()
data = value.data()
h = self.hexencode(data)
#warn('DATA: %s' % h)
#DumperBase.warn('DATA: %s' % h)
string = ''.join('\\x' + h[2*i:2*i+2] for i in range(size))
exp = '(%s*)memcpy(calloc(%d, 1), "%s", %d)' \
% (value.type.name, size, string, size)
#warn('EXP: %s' % exp)
#DumperBase.warn('EXP: %s' % exp)
res = gdb.parse_and_eval(exp)
#warn('RES: %s' % res)
#DumperBase.warn('RES: %s' % res)
return toInteger(res)
def releaseValue(self, address):
@@ -824,7 +824,7 @@ class Dumper(DumperBase):
return self.cachedInferior
def readRawMemory(self, address, size):
#warn('READ: %s FROM 0x%x' % (size, address))
#DumperBase.warn('READ: %s FROM 0x%x' % (size, address))
if address == 0 or size == 0:
return bytes()
res = self.selectedInferior().read_memory(address, size)
@@ -1185,7 +1185,7 @@ class Dumper(DumperBase):
def lookupNativeTypeHelper(self, typeName):
typeobj = self.typeCache.get(typeName)
#warn('LOOKUP 1: %s -> %s' % (typeName, typeobj))
#DumperBase.warn('LOOKUP 1: %s -> %s' % (typeName, typeobj))
if not typeobj is None:
return typeobj
@@ -1217,7 +1217,7 @@ class Dumper(DumperBase):
self.typesToReport[typeName] = typeobj
return typeobj
#warn(" RESULT FOR 7.2: '%s': %s" % (typeName, typeobj))
#DumperBase.warn(" RESULT FOR 7.2: '%s': %s" % (typeName, typeobj))
# This part should only trigger for
# gdb 7.1 for types with namespace separators.
@@ -1255,24 +1255,24 @@ class Dumper(DumperBase):
return typeobj
try:
#warn("LOOKING UP 1 '%s'" % ts)
#DumperBase.warn("LOOKING UP 1 '%s'" % ts)
typeobj = gdb.lookup_type(ts)
except RuntimeError as error:
#warn("LOOKING UP 2 '%s' ERROR %s" % (ts, error))
#DumperBase.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()
#warn("LOOKING UP 3 '%s'" % typeobj)
#DumperBase.warn("LOOKING UP 3 '%s'" % typeobj)
except:
# Can throw 'RuntimeError: No type named class Foo.'
pass
except:
#warn("LOOKING UP '%s' FAILED" % ts)
#DumperBase.warn("LOOKING UP '%s' FAILED" % ts)
pass
if not typeobj is None:
#warn('CACHING: %s' % typeobj)
#DumperBase.warn('CACHING: %s' % typeobj)
self.typeCache[typeName] = typeobj
self.typesToReport[typeName] = typeobj

169
share/qtcreator/debugger/lldbbridge.py
View File

@@ -31,6 +31,8 @@ import sys
import threading
import time
import lldb
import utils
from utils import DebuggerStartMode, BreakpointType, TypeCode
from contextlib import contextmanager
@@ -154,23 +156,23 @@ class Dumper(DumperBase):
targetType = self.fromNativeType(nativeTargetType)
val = self.createReferenceValue(nativeValue.GetValueAsUnsigned(), targetType)
val.laddress = nativeValue.AddressOf().GetValueAsUnsigned()
#warn('CREATED REF: %s' % val)
#DumperBase.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)
#warn('CREATED PTR 1: %s' % val)
#DumperBase.warn('CREATED PTR 1: %s' % val)
val.laddress = nativeValue.AddressOf().GetValueAsUnsigned()
#warn('CREATED PTR 2: %s' % val)
#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)
#warn('CREATED TYPEDEF: %s' % val)
#DumperBase.warn('CREATED TYPEDEF: %s' % val)
else:
val = self.Value(self)
address = nativeValue.GetLoadAddress()
@@ -233,7 +235,7 @@ class Dumper(DumperBase):
return align
def listMembers(self, value, nativeType):
#warn("ADDR: 0x%x" % self.fakeAddress)
#DumperBase.warn("ADDR: 0x%x" % self.fakeAddress)
fakeAddress = self.fakeAddress if value.laddress is None else value.laddress
sbaddr = lldb.SBAddress(fakeAddress, self.target)
fakeValue = self.target.CreateValueFromAddress('x', sbaddr, nativeType)
@@ -359,8 +361,8 @@ class Dumper(DumperBase):
# // Define a mask that can be used for any type when finding types
# eTypeClassAny = (0xffffffffu)
#warn('CURRENT: %s' % self.typeData.keys())
#warn('FROM NATIVE TYPE: %s' % nativeType.GetName())
#DumperBase.warn('CURRENT: %s' % self.typeData.keys())
#DumperBase.warn('FROM NATIVE TYPE: %s' % nativeType.GetName())
if code == lldb.eTypeClassInvalid:
return None
@@ -368,23 +370,23 @@ class Dumper(DumperBase):
nativeType = nativeType.GetUnqualifiedType()
if code == lldb.eTypeClassPointer:
#warn('PTR')
#DumperBase.warn('PTR')
nativeTargetType = nativeType.GetPointeeType()
if not nativeTargetType.IsPointerType():
nativeTargetType = nativeTargetType.GetUnqualifiedType()
#warn('PTR: %s' % nativeTargetType.name)
#DumperBase.warn('PTR: %s' % nativeTargetType.name)
return self.createPointerType(self.fromNativeType(nativeTargetType))
if code == lldb.eTypeClassReference:
#warn('REF')
#DumperBase.warn('REF')
nativeTargetType = nativeType.GetDereferencedType()
if not nativeTargetType.IsPointerType():
nativeTargetType = nativeTargetType.GetUnqualifiedType()
#warn('REF: %s' % nativeTargetType.name)
#DumperBase.warn('REF: %s' % nativeTargetType.name)
return self.createReferenceType(self.fromNativeType(nativeTargetType))
if code == lldb.eTypeClassTypedef:
#warn('TYPEDEF')
#DumperBase.warn('TYPEDEF')
nativeTargetType = nativeType.GetUnqualifiedType()
if hasattr(nativeTargetType, 'GetCanonicalType'):
nativeTargetType = nativeTargetType.GetCanonicalType()
@@ -395,12 +397,12 @@ class Dumper(DumperBase):
typeName = self.typeName(nativeType)
if code in (lldb.eTypeClassArray, lldb.eTypeClassVector):
#warn('ARRAY: %s' % nativeType.GetName())
#DumperBase.warn('ARRAY: %s' % nativeType.GetName())
if hasattr(nativeType, 'GetArrayElementType'): # New in 3.8(?) / 350.x
nativeTargetType = nativeType.GetArrayElementType()
if not nativeTargetType.IsValid():
if hasattr(nativeType, 'GetVectorElementType'): # New in 3.8(?) / 350.x
#warn('BAD: %s ' % nativeTargetType.get_fields_array())
#DumperBase.warn('BAD: %s ' % nativeTargetType.get_fields_array())
nativeTargetType = nativeType.GetVectorElementType()
count = nativeType.GetByteSize() // nativeTargetType.GetByteSize()
targetTypeName = nativeTargetType.GetName()
@@ -408,7 +410,7 @@ class Dumper(DumperBase):
typeName = nativeType.GetName()
pos1 = typeName.rfind('[')
targetTypeName = typeName[0:pos1].strip()
#warn("TARGET TYPENAME: %s" % targetTypeName)
#DumperBase.warn("TARGET TYPENAME: %s" % targetTypeName)
targetType = self.fromNativeType(nativeTargetType)
tdata = targetType.typeData().copy()
tdata.name = targetTypeName
@@ -431,33 +433,33 @@ class Dumper(DumperBase):
tdata.name = typeName
tdata.lbitsize = nativeType.GetByteSize() * 8
if code == lldb.eTypeClassBuiltin:
if isFloatingPointTypeName(typeName):
tdata.code = TypeCodeFloat
elif isIntegralTypeName(typeName):
tdata.code = TypeCodeIntegral
if utils.isFloatingPointTypeName(typeName):
tdata.code = TypeCode.TypeCodeFloat
elif utils.isIntegralTypeName(typeName):
tdata.code = TypeCode.TypeCodeIntegral
elif typeName in ('__int128', 'unsigned __int128'):
tdata.code = TypeCodeIntegral
tdata.code = TypeCode.TypeCodeIntegral
elif typeName == 'void':
tdata.code = TypeCodeVoid
tdata.code = TypeCode.TypeCodeVoid
else:
warn('UNKNOWN TYPE KEY: %s: %s' % (typeName, code))
self.warn('UNKNOWN TYPE KEY: %s: %s' % (typeName, code))
elif code == lldb.eTypeClassEnumeration:
tdata.code = TypeCodeEnum
tdata.code = TypeCode.TypeCodeEnum
tdata.enumDisplay = lambda intval, addr, form : \
self.nativeTypeEnumDisplay(nativeType, intval, form)
elif code in (lldb.eTypeClassComplexInteger, lldb.eTypeClassComplexFloat):
tdata.code = TypeCodeComplex
tdata.code = TypeCode.TypeCodeComplex
elif code in (lldb.eTypeClassClass, lldb.eTypeClassStruct, lldb.eTypeClassUnion):
tdata.code = TypeCodeStruct
tdata.code = TypeCode.TypeCodeStruct
tdata.lalignment = lambda : \
self.nativeStructAlignment(nativeType)
tdata.lfields = lambda value : \
self.listMembers(value, nativeType)
tdata.templateArguments = self.listTemplateParametersHelper(nativeType)
elif code == lldb.eTypeClassFunction:
tdata.code = TypeCodeFunction
tdata.code = TypeCode.TypeCodeFunction
elif code == lldb.eTypeClassMemberPointer:
tdata.code = TypeCodeMemberPointer
tdata.code = TypeCode.TypeCodeMemberPointer
self.registerType(typeId, tdata) # Fix up fields and template args
# warn('CREATE TYPE: %s' % typeId)
@@ -491,12 +493,12 @@ class Dumper(DumperBase):
targs.append(self.fromNativeType(innerType))
#elif kind == lldb.eTemplateArgumentKindIntegral:
# innerType = nativeType.GetTemplateArgumentType(i).GetUnqualifiedType().GetCanonicalType()
# #warn('INNER TYP: %s' % innerType)
# #DumperBase.warn('INNER TYP: %s' % innerType)
# basicType = innerType.GetBasicType()
# #warn('IBASIC TYP: %s' % basicType)
# #DumperBase.warn('IBASIC TYP: %s' % basicType)
# inner = self.extractTemplateArgument(nativeType.GetName(), i)
# exp = '(%s)%s' % (innerType.GetName(), inner)
# #warn('EXP : %s' % exp)
# #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...
@@ -504,12 +506,12 @@ class Dumper(DumperBase):
# value = val.GetValueAsUnsigned()
# if value >= 0x8000000:
# value -= 0x100000000
# #warn('KIND: %s' % kind)
# #DumperBase.warn('KIND: %s' % kind)
# targs.append(value)
else:
#warn('UNHANDLED TEMPLATE TYPE : %s' % kind)
#DumperBase.warn('UNHANDLED TEMPLATE TYPE : %s' % kind)
targs.append(stringArgs[i]) # Best we can do.
#warn('TARGS: %s %s' % (nativeType.GetName(), [str(x) for x in targs]))
#DumperBase.warn('TARGS: %s %s' % (nativeType.GetName(), [str(x) for x in targs]))
return targs
def typeName(self, nativeType):
@@ -529,7 +531,7 @@ class Dumper(DumperBase):
return name
fields = nativeType.get_fields_array()
typeId = c + ''.join(['{%s:%s}' % (f.name, self.nativeTypeId(f.GetType())) for f in fields])
#warn('NATIVE TYPE ID FOR %s IS %s' % (name, typeId))
#DumperBase.warn('NATIVE TYPE ID FOR %s IS %s' % (name, typeId))
return typeId
def nativeTypeEnumDisplay(self, nativeType, intval, form):
@@ -614,12 +616,12 @@ class Dumper(DumperBase):
def callHelper(self, rettype, value, func, args):
# args is a tuple.
arg = ','.join(args)
#warn('PRECALL: %s -> %s(%s)' % (value.address(), func, arg))
#DumperBase.warn('PRECALL: %s -> %s(%s)' % (value.address(), func, arg))
typename = value.type.name
exp = '((%s*)0x%x)->%s(%s)' % (typename, value.address(), func, arg)
#warn('CALL: %s' % exp)
#DumperBase.warn('CALL: %s' % exp)
result = self.currentContextValue.CreateValueFromExpression('', exp)
#warn(' -> %s' % result)
#DumperBase.warn(' -> %s' % result)
return self.fromNativeValue(result)
def pokeValue(self, typeName, *args):
@@ -627,9 +629,9 @@ class Dumper(DumperBase):
frame = thread.GetFrameAtIndex(0)
inner = ','.join(args)
value = frame.EvaluateExpression(typeName + '{' + inner + '}')
#self.warn(' TYPE: %s' % value.type)
#self.warn(' ADDR: 0x%x' % value.address)
#self.warn(' VALUE: %s' % value)
#DumperBase.warn(' TYPE: %s' % value.type)
#DumperBase.warn(' ADDR: 0x%x' % value.address)
#DumperBase.warn(' VALUE: %s' % value)
return value
def nativeParseAndEvaluate(self, exp):
@@ -640,10 +642,10 @@ class Dumper(DumperBase):
#val = self.target.EvaluateExpression(exp, options)
err = val.GetError()
if err.Fail():
#warn('FAILING TO EVAL: %s' % exp)
#DumperBase.warn('FAILING TO EVAL: %s' % exp)
return None
#warn('NO ERROR.')
#warn('EVAL: %s -> %s' % (exp, val.IsValid()))
#DumperBase.warn('NO ERROR.')
#DumperBase.warn('EVAL: %s -> %s' % (exp, val.IsValid()))
return val
def parseAndEvaluate(self, exp):
@@ -749,14 +751,14 @@ class Dumper(DumperBase):
return re.sub('^(struct|class|union|enum|typedef) ', '', name)
def lookupNativeType(self, name):
#warn('LOOKUP TYPE NAME: %s' % name)
#DumperBase.warn('LOOKUP TYPE NAME: %s' % name)
typeobj = self.typeCache.get(name)
if not typeobj is None:
#warn('CACHED: %s' % name)
#DumperBase.warn('CACHED: %s' % name)
return typeobj
typeobj = self.target.FindFirstType(name)
if typeobj.IsValid():
#warn('VALID FIRST : %s' % typeobj)
#DumperBase.warn('VALID FIRST : %s' % typeobj)
self.typeCache[name] = typeobj
return typeobj
@@ -773,16 +775,16 @@ class Dumper(DumperBase):
for typeobj in typeobjlist:
n = self.canonicalTypeName(self.removeTypePrefix(typeobj.GetDisplayTypeName()))
if n == nonPrefixedName:
#warn('FOUND TYPE USING FindTypes : %s' % typeobj)
#DumperBase.warn('FOUND TYPE USING FindTypes : %s' % typeobj)
self.typeCache[name] = typeobj
return typeobj
if name.endswith('*'):
#warn('RECURSE PTR')
#DumperBase.warn('RECURSE PTR')
typeobj = self.lookupNativeType(name[:-1].strip())
if typeobj is not None:
#warn('RECURSE RESULT X: %s' % typeobj)
#DumperBase.warn('RECURSE RESULT X: %s' % typeobj)
self.fromNativeType(typeobj.GetPointerType())
#warn('RECURSE RESULT: %s' % typeobj.GetPointerType())
#DumperBase.warn('RECURSE RESULT: %s' % typeobj.GetPointerType())
return typeobj.GetPointerType()
#typeobj = self.target.FindFirstType(name[:-1].strip())
@@ -791,13 +793,13 @@ class Dumper(DumperBase):
# return typeobj.GetPointerType()
if name.endswith(' const'):
#warn('LOOKUP END CONST')
#DumperBase.warn('LOOKUP END CONST')
typeobj = self.lookupNativeType(name[:-6])
if typeobj is not None:
return typeobj
if name.startswith('const '):
#warn('LOOKUP START CONST')
#DumperBase.warn('LOOKUP START CONST')
typeobj = self.lookupNativeType(name[6:])
if typeobj is not None:
return typeobj
@@ -806,17 +808,17 @@ class Dumper(DumperBase):
def lookupNativeTypeInAllModules(self, name):
needle = self.canonicalTypeName(name)
#warn('NEEDLE: %s ' % needle)
warn('Searching for type %s across all target modules, this could be very slow' % name)
#DumperBase.warn('NEEDLE: %s ' % needle)
self.warn('Searching for type %s across all target modules, this could be very slow' % name)
for i in xrange(self.target.GetNumModules()):
module = self.target.GetModuleAtIndex(i)
# SBModule.GetType is new somewhere after early 300.x
# So this may fail.
for t in module.GetTypes():
n = self.canonicalTypeName(t.GetName())
#warn('N: %s' % n)
#DumperBase.warn('N: %s' % n)
if n == needle:
#warn('FOUND TYPE DIRECT 2: %s ' % t)
#DumperBase.warn('FOUND TYPE DIRECT 2: %s ' % t)
self.typeCache[name] = t
return t
if n == needle + '*':
@@ -824,16 +826,16 @@ class Dumper(DumperBase):
self.typeCache[name] = res
x = self.fromNativeType(res) # Register under both names
self.registerTypeAlias(x.typeId, name)
#warn('FOUND TYPE BY POINTER: %s ' % res.name)
#DumperBase.warn('FOUND TYPE BY POINTER: %s ' % res.name)
return res
if n == needle + '&':
res = t.GetDereferencedType().GetUnqualifiedType()
self.typeCache[name] = res
x = self.fromNativeType(res) # Register under both names
self.registerTypeAlias(x.typeId, name)
#warn('FOUND TYPE BY REFERENCE: %s ' % res.name)
#DumperBase.warn('FOUND TYPE BY REFERENCE: %s ' % res.name)
return res
#warn('NOT FOUND: %s ' % needle)
#DumperBase.warn('NOT FOUND: %s ' % needle)
return None
def setupInferior(self, args):
@@ -861,7 +863,7 @@ class Dumper(DumperBase):
self.ignoreStops = 0
if platform.system() == 'Linux':
if self.startMode_ == AttachCore:
if self.startMode_ == DebuggerStartMode.AttachCore:
pass
else:
if self.useTerminal_:
@@ -911,7 +913,8 @@ class Dumper(DumperBase):
self.reportState('enginerunandinferiorstopok')
else:
self.reportState('enginerunandinferiorrunok')
elif self.startMode_ == AttachToRemoteServer or self.startMode_ == AttachToRemoteProcess:
elif (self.startMode_ == DebuggerStartMode.AttachToRemoteServer
or self.startMode_ == DebuggerStartMode.AttachToRemoteProcess):
self.process = self.target.ConnectRemote(
self.debugger.GetListener(),
self.remoteChannel_, None, error)
@@ -923,7 +926,7 @@ class Dumper(DumperBase):
# and later detects that it did stop after all, so it is be
# better to mirror that and wait for the spontaneous stop.
self.reportState('enginerunandinferiorrunok')
elif self.startMode_ == AttachCore:
elif self.startMode_ == DebuggerStartMode.AttachCore:
coreFile = args.get('coreFile', '');
self.process = self.target.LoadCore(coreFile)
if self.process.IsValid():
@@ -1124,7 +1127,7 @@ class Dumper(DumperBase):
if size == 0:
return bytes()
error = lldb.SBError()
#warn("READ: %s %s" % (address, size))
#DumperBase.warn("READ: %s %s" % (address, size))
res = self.process.ReadMemory(address, size, error)
if res is None or len(res) != size:
# Using code in e.g. readToFirstZero relies on exceptions.
@@ -1307,12 +1310,12 @@ class Dumper(DumperBase):
self.handleBreakpointEvent(event)
return
if not lldb.SBProcess.EventIsProcessEvent(event):
warn("UNEXPECTED event (%s)" % event.GetType())
self.warn("UNEXPECTED event (%s)" % event.GetType())
return
out = lldb.SBStream()
event.GetDescription(out)
#warn("EVENT: %s" % event)
#DumperBase.warn("EVENT: %s" % event)
eventType = event.GetType()
msg = lldb.SBEvent.GetCStringFromEvent(event)
flavor = event.GetDataFlavor()
@@ -1430,7 +1433,7 @@ class Dumper(DumperBase):
def insertBreakpoint(self, args):
bpType = args['type']
if bpType == BreakpointByFileAndLine:
if bpType == BreakpointType.BreakpointByFileAndLine:
fileName = args['file']
if fileName.endswith('.js') or fileName.endswith('.qml'):
self.insertInterpreterBreakpoint(args)
@@ -1438,28 +1441,28 @@ class Dumper(DumperBase):
extra = ''
more = True
if bpType == BreakpointByFileAndLine:
if bpType == BreakpointType.BreakpointByFileAndLine:
bp = self.target.BreakpointCreateByLocation(
str(args['file']), int(args['line']))
elif bpType == BreakpointByFunction:
elif bpType == BreakpointType.BreakpointByFunction:
bp = self.target.BreakpointCreateByName(args['function'])
elif bpType == BreakpointByAddress:
elif bpType == BreakpointType.BreakpointByAddress:
bp = self.target.BreakpointCreateByAddress(args['address'])
elif bpType == BreakpointAtMain:
elif bpType == BreakpointType.BreakpointAtMain:
bp = self.createBreakpointAtMain()
elif bpType == BreakpointAtThrow:
elif bpType == BreakpointType.BreakpointAtThrow:
bp = self.target.BreakpointCreateForException(
lldb.eLanguageTypeC_plus_plus, False, True)
elif bpType == BreakpointAtCatch:
elif bpType == BreakpointType.BreakpointAtCatch:
bp = self.target.BreakpointCreateForException(
lldb.eLanguageTypeC_plus_plus, True, False)
elif bpType == WatchpointAtAddress:
elif bpType == BreakpointType.WatchpointAtAddress:
error = lldb.SBError()
# This might yield bp.IsValid() == False and
# error.desc == 'process is not alive'.
bp = self.target.WatchAddress(args['address'], 4, False, True, error)
extra = self.describeError(error)
elif bpType == WatchpointAtExpression:
elif bpType == BreakpointType.WatchpointAtExpression:
# FIXME: Top level-only for now.
try:
frame = self.currentFrame()
@@ -1702,7 +1705,7 @@ class Dumper(DumperBase):
else:
base = args.get('address', 0)
if int(base) == 0xffffffffffffffff:
warn('INVALID DISASSEMBLER BASE')
self.warn('INVALID DISASSEMBLER BASE')
return
addr = lldb.SBAddress(base, self.target)
instructions = self.target.ReadInstructions(addr, 100)
@@ -1736,7 +1739,7 @@ class Dumper(DumperBase):
# With lldb-3.8 files like /data/dev/creator-3.6/tests/
# auto/debugger/qt_tst_dumpers_StdVector_bfNWZa/main.cpp
# with non-existent directories appear.
warn('FILE: %s ERROR: %s' % (fileName, error))
self.warn('FILE: %s ERROR: %s' % (fileName, error))
source = ''
result += '{line="%s"' % lineNumber
result += ',file="%s"' % fileName
@@ -1836,7 +1839,7 @@ class Tester(Dumper):
self.target = self.debugger.CreateTarget(binary, None, None, True, error)
if error.GetType():
warn('ERROR: %s' % error)
self.warn('ERROR: %s' % error)
return
s = threading.Thread(target=self.testLoop, args=(args,))
@@ -1856,14 +1859,14 @@ class Tester(Dumper):
self.process = self.target.Launch(launchInfo, error)
if error.GetType():
warn('ERROR: %s' % error)
self.warn('ERROR: %s' % error)
event = lldb.SBEvent()
listener = self.debugger.GetListener()
while True:
state = self.process.GetState()
if listener.WaitForEvent(100, event):
#warn('EVENT: %s' % event)
#DumperBase.warn('EVENT: %s' % event)
state = lldb.SBProcess.GetStateFromEvent(event)
if state == lldb.eStateExited: # 10
break
@@ -1872,7 +1875,7 @@ class Tester(Dumper):
for i in xrange(0, self.process.GetNumThreads()):
thread = self.process.GetThreadAtIndex(i)
reason = thread.GetStopReason()
#warn('THREAD: %s REASON: %s' % (thread, reason))
#DumperBase.warn('THREAD: %s REASON: %s' % (thread, reason))
if (reason == lldb.eStopReasonBreakpoint or
reason == lldb.eStopReasonException or
reason == lldb.eStopReasonSignal):
@@ -1894,8 +1897,8 @@ class Tester(Dumper):
break
else:
warn('TIMEOUT')
warn('Cannot determined stopped thread')
d.warn('TIMEOUT')
d.warn('Cannot determined stopped thread')
lldb.SBDebugger.Destroy(self.debugger)
@@ -1981,7 +1984,7 @@ class SummaryDumper(Dumper, LogMixin):
return # Don't mess up lldb output
def lookupNativeTypeInAllModules(self, name):
warn('Failed to resolve type %s' % name)
d.warn('Failed to resolve type %s' % name)
return None
def dump_summary(self, valobj, expanded = False):

5
share/qtcreator/debugger/misctypes.py
View File

@@ -24,6 +24,7 @@
############################################################################
from dumper import *
from utils import TypeCode
import re
#######################################################################
@@ -100,7 +101,7 @@ def qdump____m512i(d, value):
#######################################################################
def qform__std__array():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qdump__gsl__span(d, value):
size, pointer = value.split('pp')
@@ -186,7 +187,7 @@ def qdump__NimStringDesc(d, value):
def qdump__NimGenericSequence__(d, value, regex = '^TY[\d]+$'):
code = value.type.stripTypedefs().code
if code == TypeCodeStruct:
if code == TypeCode.TypeCodeStruct:
size, reserved = d.split('pp', value)
data = value.address() + 2 * d.ptrSize()
typeobj = value['data'].type.dereference()

7
share/qtcreator/debugger/opencvtypes.py
View File

@@ -24,13 +24,14 @@
############################################################################
from dumper import *
from utils import TypeCode
def qdump__cv__Size_(d, value):
d.putValue('(%s, %s)' % (value[0].display(), value[1].display()))
d.putPlainChildren(value)
def qform__cv__Mat():
return [SeparateFormat]
return [DisplayFormat.SeparateFormat]
def qdump__cv__Mat(d, value):
(flag, dims, rows, cols, data, refcount, datastart, dataend,
@@ -43,7 +44,7 @@ def qdump__cv__Mat(d, value):
d.putPlainChildren(value)
return
if d.currentItemFormat() == SeparateFormat:
if d.currentItemFormat() == DisplayFormat.SeparateFormat:
rs = steps[0] * innerSize
cs = cols * innerSize
dform = 'arraydata:separate:int:%d::2:%d:%d' % (innerSize, cols, rows)
@@ -53,7 +54,7 @@ def qdump__cv__Mat(d, value):
d.putValue('(%s x %s)' % (rows, cols))
if d.isExpanded():
with Children(d):
innerType = d.createType(TypeCodeIntegral, innerSize)
innerType = d.createType(TypeCode.TypeCodeIntegral, innerSize)
for i in range(rows):
for j in range(cols):
with SubItem(d, None):

4
share/qtcreator/debugger/pdbbridge.py
View File

@@ -1552,10 +1552,10 @@ class QtcInternalDumper:
self.put('name="%s",' % name)
def isExpanded(self, iname):
# self.warn('IS EXPANDED: %s in %s' % (iname, self.expandedINames))
# DumperBase.warn('IS EXPANDED: %s in %s' % (iname, self.expandedINames))
if iname.startswith('None'):
raise "Illegal iname '%s'" % iname
# self.warn(' --> %s' % (iname in self.expandedINames))
# DumperBase.warn(' --> %s' % (iname in self.expandedINames))
return iname in self.expandedINames
def isExpandedIName(self, iname):

86
share/qtcreator/debugger/qttypes.py
View File

@@ -26,7 +26,7 @@
import platform
import re
from dumper import *
from utils import DisplayFormat
def qdump__QAtomicInt(d, value):
d.putValue(value.integer())
@@ -44,8 +44,8 @@ def qdump__QAtomicPointer(d, value):
def qform__QByteArray():
return [Latin1StringFormat, SeparateLatin1StringFormat,
Utf8StringFormat, SeparateUtf8StringFormat ]
return [DisplayFormat.Latin1StringFormat, DisplayFormat.SeparateLatin1StringFormat,
DisplayFormat.Utf8StringFormat, DisplayFormat.SeparateUtf8StringFormat ]
def qedit__QByteArray(d, value, data):
d.call('void', value, 'resize', str(len(data)))
@@ -58,14 +58,14 @@ def qdump__QByteArray(d, value):
d.putNumChild(size)
elided, p = d.encodeByteArrayHelper(d.extractPointer(value), d.displayStringLimit)
displayFormat = d.currentItemFormat()
if displayFormat == AutomaticFormat or displayFormat == Latin1StringFormat:
if displayFormat == DisplayFormat.AutomaticFormat or displayFormat == DisplayFormat.Latin1StringFormat:
d.putValue(p, 'latin1', elided=elided)
elif displayFormat == SeparateLatin1StringFormat:
elif displayFormat == DisplayFormat.SeparateLatin1StringFormat:
d.putValue(p, 'latin1', elided=elided)
d.putDisplay('latin1:separate', d.encodeByteArray(value, limit=100000))
elif displayFormat == Utf8StringFormat:
elif displayFormat == DisplayFormat.Utf8StringFormat:
d.putValue(p, 'utf8', elided=elided)
elif displayFormat == SeparateUtf8StringFormat:
elif displayFormat == DisplayFormat.SeparateUtf8StringFormat:
d.putValue(p, 'utf8', elided=elided)
d.putDisplay('utf8:separate', d.encodeByteArray(value, limit=100000))
if d.isExpanded():
@@ -103,11 +103,11 @@ def qdump__QChar(d, value):
def qform_X_QAbstractItemModel():
return [SimpleFormat, EnhancedFormat]
return [DisplayFormat.SimpleFormat, DisplayFormat.EnhancedFormat]
def qdump_X_QAbstractItemModel(d, value):
displayFormat = d.currentItemFormat()
if displayFormat == SimpleFormat:
if displayFormat == DisplayFormat.SimpleFormat:
d.putPlainChildren(value)
return
#displayFormat == EnhancedFormat:
@@ -137,11 +137,11 @@ def qdump_X_QAbstractItemModel(d, value):
#gdb.execute('call free($ri)')
def qform_X_QModelIndex():
return [SimpleFormat, EnhancedFormat]
return [DisplayFormat.SimpleFormat, DisplayFormat.EnhancedFormat]
def qdump_X_QModelIndex(d, value):
displayFormat = d.currentItemFormat()
if displayFormat == SimpleFormat:
if displayFormat == DisplayFormat.SimpleFormat:
d.putPlainChildren(value)
return
r = value['r']
@@ -306,12 +306,12 @@ def qdump__QDateTime(d, value):
is32bit = d.ptrSize() == 4
if qtVersion >= 0x050200:
tiVersion = d.qtTypeInfoVersion()
#warn('TI VERSION: %s' % tiVersion)
#DumperBase.warn('TI VERSION: %s' % tiVersion)
if tiVersion is None:
tiVersion = 4
if tiVersion > 10:
status = d.extractByte(value)
#warn('STATUS: %s' % status)
#DumperBase.warn('STATUS: %s' % status)
if status & 0x01:
# Short data
msecs = d.extractUInt64(value) >> 8
@@ -757,7 +757,7 @@ def qdump__QFixed(d, value):
def qform__QFiniteStack():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qdump__QFiniteStack(d, value):
array, alloc, size = value.split('pii')
@@ -775,7 +775,7 @@ def qdump__QFlags(d, value):
def qform__QHash():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__QHash(d, value):
qdumpHelper_QHash(d, value, value.type[0], value.type[1])
@@ -835,7 +835,7 @@ def qdumpHelper_QHash(d, value, keyType, valueType):
def qform__QHashNode():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__QHashNode(d, value):
d.putPairItem(None, value)
@@ -872,7 +872,7 @@ def qdump__QHostAddress(d, value):
dd = d.extractPointer(value)
qtVersion = d.qtVersion()
tiVersion = d.qtTypeInfoVersion()
#warn('QT: %x, TI: %s' % (qtVersion, tiVersion))
#DumperBase.warn('QT: %x, TI: %s' % (qtVersion, tiVersion))
mayNeedParse = True
if tiVersion is not None:
if tiVersion >= 16:
@@ -942,7 +942,7 @@ def qdump__QIPv6Address(d, value):
d.putArrayData(value.address(), 16, d.lookupType('unsigned char'))
def qform__QList():
return [DirectQListStorageFormat, IndirectQListStorageFormat]
return [DisplayFormat.DirectQListStorageFormat, DisplayFormat.IndirectQListStorageFormat]
def qdump__QList(d, value):
return qdumpHelper_QList(d, value, value.type[0])
@@ -972,9 +972,9 @@ def qdumpHelper_QList(d, value, innerType):
# in the frontend.
# So as first approximation only do the 'isLarge' check:
displayFormat = d.currentItemFormat()
if displayFormat == DirectQListStorageFormat:
if displayFormat == DisplayFormat.DirectQListStorageFormat:
isInternal = True
elif displayFormat == IndirectQListStorageFormat:
elif displayFormat == DisplayFormat.IndirectQListStorageFormat:
isInternal = False
else:
isInternal = innerSize <= stepSize and innerType.isMovableType()
@@ -995,7 +995,7 @@ def qdumpHelper_QList(d, value, innerType):
d.putSubItem(i, x)
def qform__QImage():
return [SimpleFormat, SeparateFormat]
return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat]
def qdump__QImage(d, value):
if d.qtVersion() < 0x050000:
@@ -1024,7 +1024,7 @@ def qdump__QImage(d, value):
d.putType('void *')
displayFormat = d.currentItemFormat()
if displayFormat == SeparateFormat:
if displayFormat == DisplayFormat.SeparateFormat:
d.putDisplay('imagedata:separate', '%08x%08x%08x%08x' % (width, height, nbytes, iformat)
+ d.readMemory(bits, nbytes))
@@ -1167,7 +1167,7 @@ def qdumpHelper_Qt5_QMap(d, value, keyType, valueType):
def qform__QMap():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__QMap(d, value):
qdumpHelper_QMap(d, value, value.type[0], value.type[1])
@@ -1179,13 +1179,13 @@ def qdumpHelper_QMap(d, value, keyType, valueType):
qdumpHelper_Qt5_QMap(d, value, keyType, valueType)
def qform__QMultiMap():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__QMultiMap(d, value):
qdump__QMap(d, value)
def qform__QVariantMap():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__QVariantMap(d, value):
qdumpHelper_QMap(d, value, d.createType('QString'), d.createType('QVariant'))
@@ -1458,7 +1458,7 @@ def qdump__QSizePolicy(d, value):
def qform__QStack():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qdump__QStack(d, value):
qdump__QVector(d, value)
@@ -1492,14 +1492,14 @@ def qedit__QString(d, value, data):
d.setValues(base, 'short', [ord(c) for c in data])
def qform__QString():
return [SimpleFormat, SeparateFormat]
return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat]
def qdump__QString(d, value):
d.putStringValue(value)
(data, size, alloc) = d.stringData(value)
d.putNumChild(size)
displayFormat = d.currentItemFormat()
if displayFormat == SeparateFormat:
if displayFormat == DisplayFormat.SeparateFormat:
d.putDisplay('utf16:separate', d.encodeString(value, limit=100000))
if d.isExpanded():
d.putArrayData(data, size, d.createType('QChar'))
@@ -1596,7 +1596,7 @@ def qdump__QTextDocument(d, value):
def qform__QUrl():
return [SimpleFormat, SeparateFormat]
return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat]
def qdump__QUrl(d, value):
privAddress = d.extractPointer(value)
@@ -1637,7 +1637,7 @@ def qdump__QUrl(d, value):
d.putValue(url, 'utf16')
displayFormat = d.currentItemFormat()
if displayFormat == SeparateFormat:
if displayFormat == DisplayFormat.SeparateFormat:
d.putDisplay('utf16:separate', url)
d.putNumChild(1)
@@ -1851,7 +1851,7 @@ def qdump__QVariant(d, value):
d.putNumChild(0)
return None
#warn('TYPE: %s' % variantType)
#DumperBase.warn('TYPE: %s' % variantType)
if variantType <= 86:
# Known Core or Gui type.
@@ -1867,15 +1867,15 @@ def qdump__QVariant(d, value):
#data = value['d']['data']
innerType = d.qtNamespace() + innert
#warn('SHARED: %s' % isShared)
#DumperBase.warn('SHARED: %s' % isShared)
if isShared:
base1 = d.extractPointer(value)
#warn('BASE 1: %s %s' % (base1, innert))
#DumperBase.warn('BASE 1: %s %s' % (base1, innert))
base = d.extractPointer(base1)
#warn('SIZE 1: %s' % size)
#DumperBase.warn('SIZE 1: %s' % size)
val = d.createValue(base, innerType)
else:
#warn('DIRECT ITEM 1: %s' % innerType)
#DumperBase.warn('DIRECT ITEM 1: %s' % innerType)
val = d.createValue(data, innerType)
val.laddress = value.laddress
@@ -1939,7 +1939,7 @@ def qedit__QVector(d, value, data):
def qform__QVector():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qdump__QVector(d, value):
@@ -2053,17 +2053,17 @@ def qdump__QXmlStreamAttribute(d, value):
#######################################################################
def extractQmlData(d, value):
#if value.type.code == TypeCodePointer:
#if value.type.code == TypeCode.TypeCodePointer:
# value = value.dereference()
base = value.split('p')[0]
#mmdata = d.split('Q', base)[0]
#PointerMask = 0xfffffffffffffffd
#vtable = mmdata & PointerMask
#warn('QML DATA: %s' % value.stringify())
#DumperBase.warn('QML DATA: %s' % value.stringify())
#data = value['data']
#return #data.cast(d.lookupType(value.type.name.replace('QV4::', 'QV4::Heap::')))
typeName = value.type.name.replace('QV4::', 'QV4::Heap::')
#warn('TYOE DATA: %s' % typeName)
#DumperBase.warn('TYOE DATA: %s' % typeName)
return d.createValue(base, typeName)
def qdump__QV4__Heap__Base(d, value):
@@ -2236,7 +2236,7 @@ def QV4_valueForData(d, jsval): # (Dumper, QJSValue *jsval) -> QV4::Value *
v = QV4_getValue(d, jsval)
if v:
return v
warn('Not implemented: VARIANT')
d.warn('Not implemented: VARIANT')
return 0
def QV4_putObjectValue(d, objectPtr):
@@ -2424,7 +2424,7 @@ def qdump_64__QV4__Value(d, value):
d.putBetterType('%sQV4::Value (object)' % ns)
#QV4_putObjectValue(d, d.extractPointer(value) + 2 * d.ptrSize())
arrayVTable = d.symbolAddress(ns + 'QV4::ArrayObject::static_vtbl')
#warn('ARRAY VTABLE: 0x%x' % arrayVTable)
#DumperBase.warn('ARRAY VTABLE: 0x%x' % arrayVTable)
d.putNumChild(1)
d.putItem(d.createValue(d.extractPointer(value) + 2 * d.ptrSize(), ns + 'QV4::Object'))
return
@@ -2630,7 +2630,7 @@ def qdump__QScriptValue(d, value):
payload = x['asBits']['payload']
#isValid = int(x['asBits']['tag']) != -6 # Empty
#isCell = int(x['asBits']['tag']) == -2
#warn('IS CELL: %s ' % isCell)
#DumperBase.warn('IS CELL: %s ' % isCell)
#isObject = False
#className = 'UNKNOWN NAME'
#if isCell:
@@ -2648,7 +2648,7 @@ def qdump__QScriptValue(d, value):
# type = cell['m_structure']['m_typeInfo']['m_type']
# isObject = int(type) == 7 # ObjectType;
# className = 'UNKNOWN NAME'
#warn('IS OBJECT: %s ' % isObject)
#DumperBase.warn('IS OBJECT: %s ' % isObject)
#inline bool JSCell::inherits(const ClassInfo* info) const
#for (const ClassInfo* ci = classInfo(); ci; ci = ci->parentClass) {

37
share/qtcreator/debugger/stdtypes.py
View File

@@ -23,10 +23,11 @@
#
############################################################################
from utils import DisplayFormat
from dumper import *
def qform__std__array():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qdump__std__array(d, value):
size = value.type[1]
@@ -36,7 +37,7 @@ def qdump__std__array(d, value):
def qform__std____1__array():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qdump__std____1__array(d, value):
qdump__std__array(d, value)
@@ -260,7 +261,7 @@ def qdump__std____1__list(d, value):
d.putSubItem(i, val)
def qform__std__map():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__std__map(d, value):
if d.isQnxTarget() or d.isMsvcTarget():
@@ -334,7 +335,7 @@ def qdump__std____cxx1998__map(d, value):
qdump__std__map(d, value)
def qform__std__multimap():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__std__multimap(d, value):
return qdump__std__map(d, value)
@@ -537,7 +538,7 @@ def qdump__std____1__multiset(d, value):
qdump__std____1__set(d, value)
def qform__std____1__map():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__std____1__map(d, value):
try:
@@ -574,7 +575,7 @@ def qdump__std____1__map(d, value):
d.putPairItem(i, pair, 'key', 'value')
def qform__std____1__multimap():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__std____1__multimap(d, value):
qdump__std____1__map(d, value)
@@ -620,8 +621,8 @@ def qdump__std____1__stack(d, value):
d.putBetterType(value.type)
def qform__std__string():
return [Latin1StringFormat, SeparateLatin1StringFormat,
Utf8StringFormat, SeparateUtf8StringFormat ]
return [DisplayFormat.Latin1StringFormat, DisplayFormat.SeparateLatin1StringFormat,
DisplayFormat.Utf8StringFormat, DisplayFormat.SeparateUtf8StringFormat ]
def qdump__std__string(d, value):
qdumpHelper_std__string(d, value, d.createType("char"), d.currentItemFormat())
@@ -760,10 +761,10 @@ def qdump__std__pair(d, value):
d.putValue(value.value, value.encoding)
def qform__std__unordered_map():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qform__std____debug__unordered_map():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__std__unordered_map(d, value):
if d.isQnxTarget() or d.isMsvcTarget():
@@ -861,7 +862,7 @@ def qdump__std__unordered_set(d, value):
p = d.extractPointer(p + offset)
def qform__std____1__unordered_map():
return mapForms()
return [DisplayFormat.CompactMapFormat]
def qdump__std____1__unordered_map(d, value):
(size, _) = value["__table_"]["__p2_"].split("pp")
@@ -916,7 +917,7 @@ def qdump__std____debug__unordered_multiset(d, value):
def qform__std__valarray():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qdump__std__valarray(d, value):
if d.isMsvcTarget():
@@ -928,7 +929,7 @@ def qdump__std__valarray(d, value):
def qform__std____1__valarray():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qdump__std____1__valarray(d, value):
innerType = value.type[0]
@@ -939,7 +940,7 @@ def qdump__std____1__valarray(d, value):
def qform__std__vector():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qedit__std__vector(d, value, data):
import gdb
@@ -1036,13 +1037,13 @@ def qdumpHelper__std__vector__QNX(d, value):
d.putPlotData(start, size, innerType)
def qform__std____1__vector():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qdump__std____1__vector(d, value):
qdumpHelper__std__vector(d, value, True)
def qform__std____debug__vector():
return arrayForms()
return [DisplayFormat.ArrayPlotFormat]
def qdump__std____debug__vector(d, value):
qdump__std__vector(d, value)
@@ -1088,7 +1089,7 @@ def qdump__string(d, value):
qdump__std__string(d, value)
def qform__std__wstring():
return [SimpleFormat, SeparateFormat]
return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat]
def qdump__std__wstring(d, value):
qdumpHelper_std__string(d, value, d.createType('wchar_t'), d.currentItemFormat())
@@ -1131,7 +1132,7 @@ def qdump__std____1__basic_string(d, value):
elif innerType == "wchar_t":
qdump__std____1__wstring(d, value)
else:
warn("UNKNOWN INNER TYPE %s" % innerType)
d.warn("UNKNOWN INNER TYPE %s" % innerType)
def qdump__wstring(d, value):
qdump__std__wstring(d, value)

130
share/qtcreator/debugger/utils.py Normal file
View File

@@ -0,0 +1,130 @@
############################################################################
#
# Copyright (C) 2016 The Qt Company Ltd.
# Contact: https://www.qt.io/licensing/
#
# This file is part of Qt Creator.
#
# Commercial License Usage
# Licensees holding valid commercial Qt licenses may use this file in
# accordance with the commercial license agreement provided with the
# Software or, alternatively, in accordance with the terms contained in
# a written agreement between you and The Qt Company. For licensing terms
# and conditions see https://www.qt.io/terms-conditions. For further
# information use the contact form at https://www.qt.io/contact-us.
#
# GNU General Public License Usage
# Alternatively, this file may be used under the terms of the GNU
# General Public License version 3 as published by the Free Software
# Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
# included in the packaging of this file. Please review the following
# information to ensure the GNU General Public License requirements will
# be met: https://www.gnu.org/licenses/gpl-3.0.html.
#
############################################################################
# Debugger start modes. Keep in sync with DebuggerStartMode in debuggerconstants.h
class DebuggerStartMode:
(
NoStartMode,
StartInternal,
StartExternal,
AttachExternal,
AttachCrashedExternal,
AttachCore,
AttachToRemoteServer,
AttachToRemoteProcess,
StartRemoteProcess,
) = range(0, 9)
# Known special formats. Keep in sync with DisplayFormat in debuggerprotocol.h
class DisplayFormat:
(
AutomaticFormat,
RawFormat,
SimpleFormat,
EnhancedFormat,
SeparateFormat,
Latin1StringFormat,
SeparateLatin1StringFormat,
Utf8StringFormat,
SeparateUtf8StringFormat,
Local8BitStringFormat,
Utf16StringFormat,
Ucs4StringFormat,
Array10Format,
Array100Format,
Array1000Format,
Array10000Format,
ArrayPlotFormat,
CompactMapFormat,
DirectQListStorageFormat,
IndirectQListStorageFormat,
) = range(0, 20)
# Breakpoints. Keep synchronized with BreakpointType in breakpoint.h
class BreakpointType:
(
UnknownType,
BreakpointByFileAndLine,
BreakpointByFunction,
BreakpointByAddress,
BreakpointAtThrow,
BreakpointAtCatch,
BreakpointAtMain,
BreakpointAtFork,
BreakpointAtExec,
BreakpointAtSysCall,
WatchpointAtAddress,
WatchpointAtExpression,
BreakpointOnQmlSignalEmit,
BreakpointAtJavaScriptThrow,
) = range(0, 14)
# Internal codes for types keep in sync with cdbextensions pytype.cpp
class TypeCode:
(
TypeCodeTypedef,
TypeCodeStruct,
TypeCodeVoid,
TypeCodeIntegral,
TypeCodeFloat,
TypeCodeEnum,
TypeCodePointer,
TypeCodeArray,
TypeCodeComplex,
TypeCodeReference,
TypeCodeFunction,
TypeCodeMemberPointer,
TypeCodeFortranString,
TypeCodeUnresolvable,
TypeCodeBitfield,
TypeCodeRValueReference,
) = range(0, 16)
def isIntegralTypeName(name):
return name in (
"int",
"unsigned int",
"signed int",
"short",
"unsigned short",
"long",
"unsigned long",
"long long",
"unsigned long long",
"char",
"signed char",
"unsigned char",
"bool",
)
def isFloatingPointTypeName(name):
return name in ("float", "double", "long double")