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 sys
import cdbext import cdbext
import re import re
from utils import TypeCode
sys.path.insert(1, os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))) 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): def code(self):
if self.typeName.endswith('*'): if self.typeName.endswith('*'):
return TypeCodePointer return TypeCode.TypeCodePointer
if self.typeName.endswith(']'): if self.typeName.endswith(']'):
return TypeCodeArray return TypeCode.TypeCodeArray
return TypeCodeVoid return TypeCode.TypeCodeVoid
def unqualified(self): def unqualified(self):
return self return self
def target(self): def target(self):
code = self.code() code = self.code()
if code == TypeCodePointer: if code == TypeCode.TypeCodePointer:
return FakeVoidType(self.typeName[:-1], self.dumper) return FakeVoidType(self.typeName[:-1], self.dumper)
if code == TypeCodeVoid: if code == TypeCode.TypeCodeVoid:
return self return self
try: try:
return FakeVoidType(self.typeName[:self.typeName.rindex('[')], self.dumper) return FakeVoidType(self.typeName[:self.typeName.rindex('[')], self.dumper)
@@ -105,7 +106,7 @@ class Dumper(DumperBase):
val.type = self.fromNativeType(nativeValue.type()) val.type = self.fromNativeType(nativeValue.type())
# There is no cdb api for the size of bitfields. # There is no cdb api for the size of bitfields.
# Workaround this issue by parsing the native debugger text for integral types. # 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() integerString = nativeValue.nativeDebuggerValue()
if integerString == 'true': if integerString == 'true':
val.ldata = int(1).to_bytes(1, byteorder='little') val.ldata = int(1).to_bytes(1, byteorder='little')
@@ -128,7 +129,7 @@ class Dumper(DumperBase):
except: except:
# read raw memory in case the integerString can not be interpreted # read raw memory in case the integerString can not be interpreted
pass pass
if val.type.code == TypeCodeEnum: if val.type.code == TypeCode.TypeCodeEnum:
val.ldisplay = self.enumValue(nativeValue) val.ldisplay = self.enumValue(nativeValue)
val.isBaseClass = val.name == val.type.name val.isBaseClass = val.name == val.type.name
val.nativeValue = nativeValue val.nativeValue = nativeValue
@@ -159,21 +160,21 @@ class Dumper(DumperBase):
nativeType = FakeVoidType(nativeType.name(), self) nativeType = FakeVoidType(nativeType.name(), self)
code = nativeType.code() code = nativeType.code()
if code == TypeCodePointer: if code == TypeCode.TypeCodePointer:
if not nativeType.name().startswith('<function>'): if not nativeType.name().startswith('<function>'):
targetType = self.lookupType(nativeType.targetName(), nativeType.moduleId()) targetType = self.lookupType(nativeType.targetName(), nativeType.moduleId())
if targetType is not None: if targetType is not None:
return self.createPointerType(targetType) 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 # 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 # 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 '): if not nativeType.name().startswith('__fptr()') and not nativeType.name().startswith('<gentype '):
targetType = self.lookupType(nativeType.targetName(), nativeType.moduleId()) targetType = self.lookupType(nativeType.targetName(), nativeType.moduleId())
if targetType is not None: if targetType is not None:
return self.createArrayType(targetType, nativeType.arrayElements()) return self.createArrayType(targetType, nativeType.arrayElements())
code = TypeCodeStruct code = TypeCode.TypeCodeStruct
tdata = self.TypeData(self) tdata = self.TypeData(self)
tdata.name = nativeType.name() tdata.name = nativeType.name()
@@ -182,12 +183,12 @@ class Dumper(DumperBase):
tdata.code = code tdata.code = code
tdata.moduleName = nativeType.module() tdata.moduleName = nativeType.module()
self.registerType(typeId, tdata) # Prevent recursion in fields. self.registerType(typeId, tdata) # Prevent recursion in fields.
if code == TypeCodeStruct: if code == TypeCode.TypeCodeStruct:
tdata.lfields = lambda value : \ tdata.lfields = lambda value : \
self.listFields(nativeType, value) self.listFields(nativeType, value)
tdata.lalignment = lambda : \ tdata.lalignment = lambda : \
self.nativeStructAlignment(nativeType) self.nativeStructAlignment(nativeType)
if code == TypeCodeEnum: if code == TypeCode.TypeCodeEnum:
tdata.enumDisplay = lambda intval, addr, form : \ tdata.enumDisplay = lambda intval, addr, form : \
self.nativeTypeEnumDisplay(nativeType, intval, form) self.nativeTypeEnumDisplay(nativeType, intval, form)
tdata.templateArguments = self.listTemplateParameters(nativeType.name()) tdata.templateArguments = self.listTemplateParameters(nativeType.name())
@@ -206,7 +207,7 @@ class Dumper(DumperBase):
nativeMember = nativeValue.childFromIndex(index) nativeMember = nativeValue.childFromIndex(index)
def nativeStructAlignment(self, nativeType): def nativeStructAlignment(self, nativeType):
#warn("NATIVE ALIGN FOR %s" % nativeType.name) #DumperBase.warn("NATIVE ALIGN FOR %s" % nativeType.name)
def handleItem(nativeFieldType, align): def handleItem(nativeFieldType, align):
a = self.fromNativeType(nativeFieldType).alignment() a = self.fromNativeType(nativeFieldType).alignment()
return a if a > align else align 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"]) data, size, alloc = d.byteArrayData(value["m_src"])
length = value["f"]["utf16chars"].integer() length = value["f"]["utf16chars"].integer()
offset = value["utf16charOffset"].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)) # % (size, alloc, offset, length, data))
d.putValue(d.readMemory(data + offset, min(100, length)), "latin1") d.putValue(d.readMemory(data + offset, min(100, length)), "latin1")
d.putPlainChildren(value) 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 import types
from dumper import * from dumper import *
from utils import TypeCode
####################################################################### #######################################################################
# #
@@ -168,7 +168,7 @@ def importPlainDumpers(args):
gdb.execute('disable pretty-printer .* .*') gdb.execute('disable pretty-printer .* .*')
except: except:
# Might occur in non-ASCII directories # Might occur in non-ASCII directories
warn('COULD NOT DISABLE PRETTY PRINTERS') DumperBase.warn('COULD NOT DISABLE PRETTY PRINTERS')
else: else:
theDumper.importPlainDumpers() theDumper.importPlainDumpers()
@@ -186,7 +186,7 @@ class OutputSaver:
def __exit__(self, exType, exValue, exTraceBack): def __exit__(self, exType, exValue, exTraceBack):
if self.d.passExceptions and not exType is None: 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 self.d.output = self.savedOutput
else: else:
self.savedOutput += self.d.output self.savedOutput += self.d.output
@@ -217,7 +217,7 @@ class Dumper(DumperBase):
self.setVariableFetchingOptions(args) self.setVariableFetchingOptions(args)
def fromFrameValue(self, nativeValue): def fromFrameValue(self, nativeValue):
#warn('FROM FRAME VALUE: %s' % nativeValue.address) #DumperBase.warn('FROM FRAME VALUE: %s' % nativeValue.address)
val = nativeValue val = nativeValue
try: try:
val = nativeValue.cast(nativeValue.dynamic_type) val = nativeValue.cast(nativeValue.dynamic_type)
@@ -226,7 +226,7 @@ class Dumper(DumperBase):
return self.fromNativeValue(val) return self.fromNativeValue(val)
def fromNativeValue(self, nativeValue): def fromNativeValue(self, nativeValue):
#warn('FROM NATIVE VALUE: %s' % nativeValue) #DumperBase.warn('FROM NATIVE VALUE: %s' % nativeValue)
self.check(isinstance(nativeValue, gdb.Value)) self.check(isinstance(nativeValue, gdb.Value))
nativeType = nativeValue.type nativeType = nativeValue.type
code = nativeType.code code = nativeType.code
@@ -234,7 +234,7 @@ class Dumper(DumperBase):
targetType = self.fromNativeType(nativeType.target().unqualified()) targetType = self.fromNativeType(nativeType.target().unqualified())
val = self.createReferenceValue(toInteger(nativeValue.address), targetType) val = self.createReferenceValue(toInteger(nativeValue.address), targetType)
val.nativeValue = nativeValue val.nativeValue = nativeValue
#warn('CREATED REF: %s' % val) #DumperBase.warn('CREATED REF: %s' % val)
return val return val
if code == gdb.TYPE_CODE_PTR: if code == gdb.TYPE_CODE_PTR:
try: try:
@@ -248,14 +248,14 @@ class Dumper(DumperBase):
# later which # later which
# is surprisingly expensive. # is surprisingly expensive.
val.nativeValue = nativeValue val.nativeValue = nativeValue
#warn('CREATED PTR 1: %s' % val) #DumperBase.warn('CREATED PTR 1: %s' % val)
if not nativeValue.address is None: if not nativeValue.address is None:
val.laddress = toInteger(nativeValue.address) val.laddress = toInteger(nativeValue.address)
#warn('CREATED PTR 2: %s' % val) #DumperBase.warn('CREATED PTR 2: %s' % val)
return val return val
if code == gdb.TYPE_CODE_TYPEDEF: if code == gdb.TYPE_CODE_TYPEDEF:
targetType = nativeType.strip_typedefs().unqualified() targetType = nativeType.strip_typedefs().unqualified()
#warn('TARGET TYPE: %s' % targetType) #DumperBase.warn('TARGET TYPE: %s' % targetType)
if targetType.code == gdb.TYPE_CODE_ARRAY: if targetType.code == gdb.TYPE_CODE_ARRAY:
val = self.Value(self) val = self.Value(self)
else: else:
@@ -267,7 +267,7 @@ class Dumper(DumperBase):
val = self.fromNativeValue(nativeValue.cast(targetType)) val = self.fromNativeValue(nativeValue.cast(targetType))
except: except:
val = self.Value(self) val = self.Value(self)
#warn('CREATED TYPEDEF: %s' % val) #DumperBase.warn('CREATED TYPEDEF: %s' % val)
else: else:
val = self.Value(self) val = self.Value(self)
@@ -308,34 +308,34 @@ class Dumper(DumperBase):
def fromNativeType(self, nativeType): def fromNativeType(self, nativeType):
self.check(isinstance(nativeType, gdb.Type)) self.check(isinstance(nativeType, gdb.Type))
code = nativeType.code code = nativeType.code
#warn('FROM NATIVE TYPE: %s' % nativeType) #DumperBase.warn('FROM NATIVE TYPE: %s' % nativeType)
nativeType = nativeType.unqualified() nativeType = nativeType.unqualified()
if code == gdb.TYPE_CODE_PTR: if code == gdb.TYPE_CODE_PTR:
#warn('PTR') #DumperBase.warn('PTR')
targetType = self.fromNativeType(nativeType.target().unqualified()) targetType = self.fromNativeType(nativeType.target().unqualified())
return self.createPointerType(targetType) return self.createPointerType(targetType)
if code == gdb.TYPE_CODE_REF: if code == gdb.TYPE_CODE_REF:
#warn('REF') #DumperBase.warn('REF')
targetType = self.fromNativeType(nativeType.target().unqualified()) targetType = self.fromNativeType(nativeType.target().unqualified())
return self.createReferenceType(targetType) return self.createReferenceType(targetType)
if hasattr(gdb, "TYPE_CODE_RVALUE_REF"): if hasattr(gdb, "TYPE_CODE_RVALUE_REF"):
if code == gdb.TYPE_CODE_RVALUE_REF: if code == gdb.TYPE_CODE_RVALUE_REF:
#warn('RVALUEREF') #DumperBase.warn('RVALUEREF')
targetType = self.fromNativeType(nativeType.target()) targetType = self.fromNativeType(nativeType.target())
return self.createRValueReferenceType(targetType) return self.createRValueReferenceType(targetType)
if code == gdb.TYPE_CODE_ARRAY: if code == gdb.TYPE_CODE_ARRAY:
#warn('ARRAY') #DumperBase.warn('ARRAY')
nativeTargetType = nativeType.target().unqualified() nativeTargetType = nativeType.target().unqualified()
targetType = self.fromNativeType(nativeTargetType) targetType = self.fromNativeType(nativeTargetType)
count = nativeType.sizeof // nativeTargetType.sizeof count = nativeType.sizeof // nativeTargetType.sizeof
return self.createArrayType(targetType, count) return self.createArrayType(targetType, count)
if code == gdb.TYPE_CODE_TYPEDEF: if code == gdb.TYPE_CODE_TYPEDEF:
#warn('TYPEDEF') #DumperBase.warn('TYPEDEF')
nativeTargetType = nativeType.unqualified() nativeTargetType = nativeType.unqualified()
while nativeTargetType.code == gdb.TYPE_CODE_TYPEDEF: while nativeTargetType.code == gdb.TYPE_CODE_TYPEDEF:
nativeTargetType = nativeTargetType.strip_typedefs().unqualified() nativeTargetType = nativeTargetType.strip_typedefs().unqualified()
@@ -344,7 +344,7 @@ class Dumper(DumperBase):
self.nativeTypeId(nativeType)) self.nativeTypeId(nativeType))
if code == gdb.TYPE_CODE_ERROR: if code == gdb.TYPE_CODE_ERROR:
warn('Type error: %s' % nativeType) self.warn('Type error: %s' % nativeType)
return self.Type(self, '') return self.Type(self, '')
typeId = self.nativeTypeId(nativeType) typeId = self.nativeTypeId(nativeType)
@@ -356,28 +356,28 @@ class Dumper(DumperBase):
tdata.lbitsize = nativeType.sizeof * 8 tdata.lbitsize = nativeType.sizeof * 8
tdata.code = { tdata.code = {
#gdb.TYPE_CODE_TYPEDEF : TypeCodeTypedef, # Handled above. #gdb.TYPE_CODE_TYPEDEF : TypeCodeTypedef, # Handled above.
gdb.TYPE_CODE_METHOD : TypeCodeFunction, gdb.TYPE_CODE_METHOD : TypeCode.TypeCodeFunction,
gdb.TYPE_CODE_VOID : TypeCodeVoid, gdb.TYPE_CODE_VOID : TypeCode.TypeCodeVoid,
gdb.TYPE_CODE_FUNC : TypeCodeFunction, gdb.TYPE_CODE_FUNC : TypeCode.TypeCodeFunction,
gdb.TYPE_CODE_METHODPTR : TypeCodeFunction, gdb.TYPE_CODE_METHODPTR : TypeCode.TypeCodeFunction,
gdb.TYPE_CODE_MEMBERPTR : TypeCodeFunction, gdb.TYPE_CODE_MEMBERPTR : TypeCode.TypeCodeFunction,
#gdb.TYPE_CODE_PTR : TypeCodePointer, # Handled above. #gdb.TYPE_CODE_PTR : TypeCode.TypeCodePointer, # Handled above.
#gdb.TYPE_CODE_REF : TypeCodeReference, # Handled above. #gdb.TYPE_CODE_REF : TypeCode.TypeCodeReference, # Handled above.
gdb.TYPE_CODE_BOOL : TypeCodeIntegral, gdb.TYPE_CODE_BOOL : TypeCode.TypeCodeIntegral,
gdb.TYPE_CODE_CHAR : TypeCodeIntegral, gdb.TYPE_CODE_CHAR : TypeCode.TypeCodeIntegral,
gdb.TYPE_CODE_INT : TypeCodeIntegral, gdb.TYPE_CODE_INT : TypeCode.TypeCodeIntegral,
gdb.TYPE_CODE_FLT : TypeCodeFloat, gdb.TYPE_CODE_FLT : TypeCode.TypeCodeFloat,
gdb.TYPE_CODE_ENUM : TypeCodeEnum, gdb.TYPE_CODE_ENUM : TypeCode.TypeCodeEnum,
#gdb.TYPE_CODE_ARRAY : TypeCodeArray, #gdb.TYPE_CODE_ARRAY : TypeCode.TypeCodeArray,
gdb.TYPE_CODE_STRUCT : TypeCodeStruct, gdb.TYPE_CODE_STRUCT : TypeCode.TypeCodeStruct,
gdb.TYPE_CODE_UNION : TypeCodeStruct, gdb.TYPE_CODE_UNION : TypeCode.TypeCodeStruct,
gdb.TYPE_CODE_COMPLEX : TypeCodeComplex, gdb.TYPE_CODE_COMPLEX : TypeCode.TypeCodeComplex,
gdb.TYPE_CODE_STRING : TypeCodeFortranString, gdb.TYPE_CODE_STRING : TypeCode.TypeCodeFortranString,
}[code] }[code]
if tdata.code == TypeCodeEnum: if tdata.code == TypeCode.TypeCodeEnum:
tdata.enumDisplay = lambda intval, addr, form : \ tdata.enumDisplay = lambda intval, addr, form : \
self.nativeTypeEnumDisplay(nativeType, intval, form) self.nativeTypeEnumDisplay(nativeType, intval, form)
if tdata.code == TypeCodeStruct: if tdata.code == TypeCode.TypeCodeStruct:
tdata.lalignment = lambda : \ tdata.lalignment = lambda : \
self.nativeStructAlignment(nativeType) self.nativeStructAlignment(nativeType)
tdata.lfields = lambda value : \ tdata.lfields = lambda value : \
@@ -402,7 +402,7 @@ class Dumper(DumperBase):
elif isinstance(targ, gdb.Value): elif isinstance(targ, gdb.Value):
targs.append(self.fromNativeValue(targ).value()) targs.append(self.fromNativeValue(targ).value())
else: else:
error('UNKNOWN TEMPLATE PARAMETER') raise RuntimeError('UNKNOWN TEMPLATE PARAMETER')
pos += 1 pos += 1
targs2 = self.listTemplateParametersManually(str(nativeType)) targs2 = self.listTemplateParametersManually(str(nativeType))
return targs if len(targs) >= len(targs2) else targs2 return targs if len(targs) >= len(targs2) else targs2
@@ -451,7 +451,7 @@ class Dumper(DumperBase):
return typeId return typeId
def nativeStructAlignment(self, nativeType): def nativeStructAlignment(self, nativeType):
#warn('NATIVE ALIGN FOR %s' % nativeType.name) #DumperBase.warn('NATIVE ALIGN FOR %s' % nativeType.name)
def handleItem(nativeFieldType, align): def handleItem(nativeFieldType, align):
a = self.fromNativeType(nativeFieldType).alignment() a = self.fromNativeType(nativeFieldType).alignment()
return a if a > align else align return a if a > align else align
@@ -507,7 +507,7 @@ class Dumper(DumperBase):
anonNumber = 0 anonNumber = 0
#warn('LISTING FIELDS FOR %s' % nativeType) #DumperBase.warn('LISTING FIELDS FOR %s' % nativeType)
for nativeField in nativeType.fields(): for nativeField in nativeType.fields():
fieldName = nativeField.name fieldName = nativeField.name
# Something without a name. # Something without a name.
@@ -521,7 +521,7 @@ class Dumper(DumperBase):
# multiple anonymous unions in the struct. # multiple anonymous unions in the struct.
anonNumber += 1 anonNumber += 1
fieldName = '#%s' % anonNumber fieldName = '#%s' % anonNumber
#warn('FIELD: %s' % fieldName) #DumperBase.warn('FIELD: %s' % fieldName)
# hasattr(nativeField, 'bitpos') == False indicates a static field, # 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 .fromNativeField will
# also succeed. We essentially skip only static members from # also succeed. We essentially skip only static members from
@@ -531,8 +531,8 @@ class Dumper(DumperBase):
def fromNativeField(self, nativeField, nativeValue, fieldName): def fromNativeField(self, nativeField, nativeValue, fieldName):
nativeFieldType = nativeField.type.unqualified() nativeFieldType = nativeField.type.unqualified()
#warn(' TYPE: %s' % nativeFieldType) #DumperBase.warn(' TYPE: %s' % nativeFieldType)
#warn(' TYPEID: %s' % self.nativeTypeId(nativeFieldType)) #DumperBase.warn(' TYPEID: %s' % self.nativeTypeId(nativeFieldType))
if hasattr(nativeField, 'bitpos'): if hasattr(nativeField, 'bitpos'):
bitpos = nativeField.bitpos bitpos = nativeField.bitpos
@@ -562,7 +562,7 @@ class Dumper(DumperBase):
capturedFieldName, capturedFieldName,
value) 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, return self.Field(dumper=self, name=fieldName, isBase=nativeField.is_base_class,
bitsize=bitsize, bitpos=bitpos, type=fieldType, bitsize=bitsize, bitpos=bitpos, type=fieldType,
extractor=extractor) extractor=extractor)
@@ -574,19 +574,19 @@ class Dumper(DumperBase):
try: try:
block = frame.block() block = frame.block()
#warn('BLOCK: %s ' % block) #DumperBase.warn('BLOCK: %s ' % block)
except RuntimeError as error: except RuntimeError as error:
#warn('BLOCK IN FRAME NOT ACCESSIBLE: %s' % error) #DumperBase.warn('BLOCK IN FRAME NOT ACCESSIBLE: %s' % error)
return [] return []
except: except:
warn('BLOCK NOT ACCESSIBLE FOR UNKNOWN REASONS') self.warn('BLOCK NOT ACCESSIBLE FOR UNKNOWN REASONS')
return [] return []
items = [] items = []
shadowed = {} shadowed = {}
while True: while True:
if block is None: if block is None:
warn("UNEXPECTED 'None' BLOCK") self.warn("UNEXPECTED 'None' BLOCK")
break break
for symbol in block: for symbol in block:
@@ -602,12 +602,12 @@ class Dumper(DumperBase):
# 'NotImplementedError: Symbol type not yet supported in # 'NotImplementedError: Symbol type not yet supported in
# Python scripts.' # 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: if self.passExceptions and not self.isTesting:
nativeValue = frame.read_var(name, block) nativeValue = frame.read_var(name, block)
value = self.fromFrameValue(nativeValue) value = self.fromFrameValue(nativeValue)
value.name = name value.name = name
#warn('READ 0: %s' % value.stringify()) #DumperBase.warn('READ 0: %s' % value.stringify())
items.append(value) items.append(value)
continue continue
@@ -616,14 +616,14 @@ class Dumper(DumperBase):
nativeValue = frame.read_var(name, block) nativeValue = frame.read_var(name, block)
value = self.fromFrameValue(nativeValue) value = self.fromFrameValue(nativeValue)
value.name = name value.name = name
#warn('READ 1: %s' % value.stringify()) #DumperBase.warn('READ 1: %s' % value.stringify())
items.append(value) items.append(value)
continue continue
except: except:
pass pass
try: try:
#warn('READ 2: %s' % item.value) #DumperBase.warn('READ 2: %s' % item.value)
value = self.fromFrameValue(frame.read_var(name)) value = self.fromFrameValue(frame.read_var(name))
value.name = name value.name = name
items.append(value) items.append(value)
@@ -637,8 +637,8 @@ class Dumper(DumperBase):
pass pass
try: try:
#warn('READ 3: %s %s' % (name, item.value)) #DumperBase.warn('READ 3: %s %s' % (name, item.value))
#warn('ITEM 3: %s' % item.value) #DumperBase.warn('ITEM 3: %s' % item.value)
value = self.fromFrameValue(gdb.parse_and_eval(name)) value = self.fromFrameValue(gdb.parse_and_eval(name))
value.name = name value.name = name
items.append(value) items.append(value)
@@ -685,7 +685,7 @@ class Dumper(DumperBase):
partialName = partialVar.split('.')[1].split('@')[0] if isPartial else None partialName = partialVar.split('.')[1].split('@')[0] if isPartial else None
variables = self.listLocals(partialName) variables = self.listLocals(partialName)
#warn('VARIABLES: %s' % variables) #DumperBase.warn('VARIABLES: %s' % variables)
# Take care of the return value of the last function call. # Take care of the return value of the last function call.
if len(self.resultVarName) > 0: if len(self.resultVarName) > 0:
@@ -728,13 +728,13 @@ class Dumper(DumperBase):
return None if val is None else self.fromNativeValue(val) return None if val is None else self.fromNativeValue(val)
def nativeParseAndEvaluate(self, exp): def nativeParseAndEvaluate(self, exp):
#warn('EVALUATE "%s"' % exp) #DumperBase.warn('EVALUATE "%s"' % exp)
try: try:
val = gdb.parse_and_eval(exp) val = gdb.parse_and_eval(exp)
return val return val
except RuntimeError as error: except RuntimeError as error:
if self.passExceptions: if self.passExceptions:
warn("Cannot evaluate '%s': %s" % (exp, error)) self.warn("Cannot evaluate '%s': %s" % (exp, error))
return None return None
def callHelper(self, rettype, value, function, args): def callHelper(self, rettype, value, function, args):
@@ -749,7 +749,7 @@ class Dumper(DumperBase):
else: else:
arg += a arg += a
#warn('CALL: %s -> %s(%s)' % (value, function, arg)) #DumperBase.warn('CALL: %s -> %s(%s)' % (value, function, arg))
typeName = value.type.name typeName = value.type.name
if typeName.find(':') >= 0: if typeName.find(':') >= 0:
typeName = "'" + typeName + "'" typeName = "'" + typeName + "'"
@@ -758,11 +758,11 @@ class Dumper(DumperBase):
addr = value.address() addr = value.address()
if addr is None: if addr is None:
addr = self.pokeValue(value) 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) 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) result = gdb.parse_and_eval(exp)
#warn(' -> %s' % result) #DumperBase.warn(' -> %s' % result)
res = self.fromNativeValue(result) res = self.fromNativeValue(result)
if value.address() is None: if value.address() is None:
self.releaseValue(addr) self.releaseValue(addr)
@@ -770,9 +770,9 @@ class Dumper(DumperBase):
def makeExpression(self, value): def makeExpression(self, value):
typename = '::' + value.type.name typename = '::' + value.type.name
#warn(' TYPE: %s' % typename) #DumperBase.warn(' TYPE: %s' % typename)
exp = '(*(%s*)(0x%x))' % (typename, value.address()) exp = '(*(%s*)(0x%x))' % (typename, value.address())
#warn(' EXP: %s' % exp) #DumperBase.warn(' EXP: %s' % exp)
return exp return exp
def makeStdString(init): def makeStdString(init):
@@ -790,13 +790,13 @@ class Dumper(DumperBase):
size = value.type.size() size = value.type.size()
data = value.data() data = value.data()
h = self.hexencode(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)) string = ''.join('\\x' + h[2*i:2*i+2] for i in range(size))
exp = '(%s*)memcpy(calloc(%d, 1), "%s", %d)' \ exp = '(%s*)memcpy(calloc(%d, 1), "%s", %d)' \
% (value.type.name, size, string, size) % (value.type.name, size, string, size)
#warn('EXP: %s' % exp) #DumperBase.warn('EXP: %s' % exp)
res = gdb.parse_and_eval(exp) res = gdb.parse_and_eval(exp)
#warn('RES: %s' % res) #DumperBase.warn('RES: %s' % res)
return toInteger(res) return toInteger(res)
def releaseValue(self, address): def releaseValue(self, address):
@@ -824,7 +824,7 @@ class Dumper(DumperBase):
return self.cachedInferior return self.cachedInferior
def readRawMemory(self, address, size): 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: if address == 0 or size == 0:
return bytes() return bytes()
res = self.selectedInferior().read_memory(address, size) res = self.selectedInferior().read_memory(address, size)
@@ -1185,7 +1185,7 @@ class Dumper(DumperBase):
def lookupNativeTypeHelper(self, typeName): def lookupNativeTypeHelper(self, typeName):
typeobj = self.typeCache.get(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: if not typeobj is None:
return typeobj return typeobj
@@ -1217,7 +1217,7 @@ class Dumper(DumperBase):
self.typesToReport[typeName] = typeobj self.typesToReport[typeName] = typeobj
return 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 # This part should only trigger for
# gdb 7.1 for types with namespace separators. # gdb 7.1 for types with namespace separators.
@@ -1255,24 +1255,24 @@ class Dumper(DumperBase):
return typeobj return typeobj
try: try:
#warn("LOOKING UP 1 '%s'" % ts) #DumperBase.warn("LOOKING UP 1 '%s'" % ts)
typeobj = gdb.lookup_type(ts) typeobj = gdb.lookup_type(ts)
except RuntimeError as error: 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 # See http://sourceware.org/bugzilla/show_bug.cgi?id=11912
exp = "(class '%s'*)0" % ts exp = "(class '%s'*)0" % ts
try: try:
typeobj = self.parse_and_eval(exp).type.target() typeobj = self.parse_and_eval(exp).type.target()
#warn("LOOKING UP 3 '%s'" % typeobj) #DumperBase.warn("LOOKING UP 3 '%s'" % typeobj)
except: except:
# Can throw 'RuntimeError: No type named class Foo.' # Can throw 'RuntimeError: No type named class Foo.'
pass pass
except: except:
#warn("LOOKING UP '%s' FAILED" % ts) #DumperBase.warn("LOOKING UP '%s' FAILED" % ts)
pass pass
if not typeobj is None: if not typeobj is None:
#warn('CACHING: %s' % typeobj) #DumperBase.warn('CACHING: %s' % typeobj)
self.typeCache[typeName] = typeobj self.typeCache[typeName] = typeobj
self.typesToReport[typeName] = typeobj self.typesToReport[typeName] = typeobj

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

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

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

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

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

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

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

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

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

@@ -26,7 +26,7 @@
import platform import platform
import re import re
from dumper import * from dumper import *
from utils import DisplayFormat
def qdump__QAtomicInt(d, value): def qdump__QAtomicInt(d, value):
d.putValue(value.integer()) d.putValue(value.integer())
@@ -44,8 +44,8 @@ def qdump__QAtomicPointer(d, value):
def qform__QByteArray(): def qform__QByteArray():
return [Latin1StringFormat, SeparateLatin1StringFormat, return [DisplayFormat.Latin1StringFormat, DisplayFormat.SeparateLatin1StringFormat,
Utf8StringFormat, SeparateUtf8StringFormat ] DisplayFormat.Utf8StringFormat, DisplayFormat.SeparateUtf8StringFormat ]
def qedit__QByteArray(d, value, data): def qedit__QByteArray(d, value, data):
d.call('void', value, 'resize', str(len(data))) d.call('void', value, 'resize', str(len(data)))
@@ -58,14 +58,14 @@ def qdump__QByteArray(d, value):
d.putNumChild(size) d.putNumChild(size)
elided, p = d.encodeByteArrayHelper(d.extractPointer(value), d.displayStringLimit) elided, p = d.encodeByteArrayHelper(d.extractPointer(value), d.displayStringLimit)
displayFormat = d.currentItemFormat() displayFormat = d.currentItemFormat()
if displayFormat == AutomaticFormat or displayFormat == Latin1StringFormat: if displayFormat == DisplayFormat.AutomaticFormat or displayFormat == DisplayFormat.Latin1StringFormat:
d.putValue(p, 'latin1', elided=elided) d.putValue(p, 'latin1', elided=elided)
elif displayFormat == SeparateLatin1StringFormat: elif displayFormat == DisplayFormat.SeparateLatin1StringFormat:
d.putValue(p, 'latin1', elided=elided) d.putValue(p, 'latin1', elided=elided)
d.putDisplay('latin1:separate', d.encodeByteArray(value, limit=100000)) d.putDisplay('latin1:separate', d.encodeByteArray(value, limit=100000))
elif displayFormat == Utf8StringFormat: elif displayFormat == DisplayFormat.Utf8StringFormat:
d.putValue(p, 'utf8', elided=elided) d.putValue(p, 'utf8', elided=elided)
elif displayFormat == SeparateUtf8StringFormat: elif displayFormat == DisplayFormat.SeparateUtf8StringFormat:
d.putValue(p, 'utf8', elided=elided) d.putValue(p, 'utf8', elided=elided)
d.putDisplay('utf8:separate', d.encodeByteArray(value, limit=100000)) d.putDisplay('utf8:separate', d.encodeByteArray(value, limit=100000))
if d.isExpanded(): if d.isExpanded():
@@ -103,11 +103,11 @@ def qdump__QChar(d, value):
def qform_X_QAbstractItemModel(): def qform_X_QAbstractItemModel():
return [SimpleFormat, EnhancedFormat] return [DisplayFormat.SimpleFormat, DisplayFormat.EnhancedFormat]
def qdump_X_QAbstractItemModel(d, value): def qdump_X_QAbstractItemModel(d, value):
displayFormat = d.currentItemFormat() displayFormat = d.currentItemFormat()
if displayFormat == SimpleFormat: if displayFormat == DisplayFormat.SimpleFormat:
d.putPlainChildren(value) d.putPlainChildren(value)
return return
#displayFormat == EnhancedFormat: #displayFormat == EnhancedFormat:
@@ -137,11 +137,11 @@ def qdump_X_QAbstractItemModel(d, value):
#gdb.execute('call free($ri)') #gdb.execute('call free($ri)')
def qform_X_QModelIndex(): def qform_X_QModelIndex():
return [SimpleFormat, EnhancedFormat] return [DisplayFormat.SimpleFormat, DisplayFormat.EnhancedFormat]
def qdump_X_QModelIndex(d, value): def qdump_X_QModelIndex(d, value):
displayFormat = d.currentItemFormat() displayFormat = d.currentItemFormat()
if displayFormat == SimpleFormat: if displayFormat == DisplayFormat.SimpleFormat:
d.putPlainChildren(value) d.putPlainChildren(value)
return return
r = value['r'] r = value['r']
@@ -306,12 +306,12 @@ def qdump__QDateTime(d, value):
is32bit = d.ptrSize() == 4 is32bit = d.ptrSize() == 4
if qtVersion >= 0x050200: if qtVersion >= 0x050200:
tiVersion = d.qtTypeInfoVersion() tiVersion = d.qtTypeInfoVersion()
#warn('TI VERSION: %s' % tiVersion) #DumperBase.warn('TI VERSION: %s' % tiVersion)
if tiVersion is None: if tiVersion is None:
tiVersion = 4 tiVersion = 4
if tiVersion > 10: if tiVersion > 10:
status = d.extractByte(value) status = d.extractByte(value)
#warn('STATUS: %s' % status) #DumperBase.warn('STATUS: %s' % status)
if status & 0x01: if status & 0x01:
# Short data # Short data
msecs = d.extractUInt64(value) >> 8 msecs = d.extractUInt64(value) >> 8
@@ -757,7 +757,7 @@ def qdump__QFixed(d, value):
def qform__QFiniteStack(): def qform__QFiniteStack():
return arrayForms() return [DisplayFormat.ArrayPlotFormat]
def qdump__QFiniteStack(d, value): def qdump__QFiniteStack(d, value):
array, alloc, size = value.split('pii') array, alloc, size = value.split('pii')
@@ -775,7 +775,7 @@ def qdump__QFlags(d, value):
def qform__QHash(): def qform__QHash():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__QHash(d, value): def qdump__QHash(d, value):
qdumpHelper_QHash(d, value, value.type[0], value.type[1]) qdumpHelper_QHash(d, value, value.type[0], value.type[1])
@@ -835,7 +835,7 @@ def qdumpHelper_QHash(d, value, keyType, valueType):
def qform__QHashNode(): def qform__QHashNode():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__QHashNode(d, value): def qdump__QHashNode(d, value):
d.putPairItem(None, value) d.putPairItem(None, value)
@@ -872,7 +872,7 @@ def qdump__QHostAddress(d, value):
dd = d.extractPointer(value) dd = d.extractPointer(value)
qtVersion = d.qtVersion() qtVersion = d.qtVersion()
tiVersion = d.qtTypeInfoVersion() tiVersion = d.qtTypeInfoVersion()
#warn('QT: %x, TI: %s' % (qtVersion, tiVersion)) #DumperBase.warn('QT: %x, TI: %s' % (qtVersion, tiVersion))
mayNeedParse = True mayNeedParse = True
if tiVersion is not None: if tiVersion is not None:
if tiVersion >= 16: if tiVersion >= 16:
@@ -942,7 +942,7 @@ def qdump__QIPv6Address(d, value):
d.putArrayData(value.address(), 16, d.lookupType('unsigned char')) d.putArrayData(value.address(), 16, d.lookupType('unsigned char'))
def qform__QList(): def qform__QList():
return [DirectQListStorageFormat, IndirectQListStorageFormat] return [DisplayFormat.DirectQListStorageFormat, DisplayFormat.IndirectQListStorageFormat]
def qdump__QList(d, value): def qdump__QList(d, value):
return qdumpHelper_QList(d, value, value.type[0]) return qdumpHelper_QList(d, value, value.type[0])
@@ -972,9 +972,9 @@ def qdumpHelper_QList(d, value, innerType):
# in the frontend. # in the frontend.
# So as first approximation only do the 'isLarge' check: # So as first approximation only do the 'isLarge' check:
displayFormat = d.currentItemFormat() displayFormat = d.currentItemFormat()
if displayFormat == DirectQListStorageFormat: if displayFormat == DisplayFormat.DirectQListStorageFormat:
isInternal = True isInternal = True
elif displayFormat == IndirectQListStorageFormat: elif displayFormat == DisplayFormat.IndirectQListStorageFormat:
isInternal = False isInternal = False
else: else:
isInternal = innerSize <= stepSize and innerType.isMovableType() isInternal = innerSize <= stepSize and innerType.isMovableType()
@@ -995,7 +995,7 @@ def qdumpHelper_QList(d, value, innerType):
d.putSubItem(i, x) d.putSubItem(i, x)
def qform__QImage(): def qform__QImage():
return [SimpleFormat, SeparateFormat] return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat]
def qdump__QImage(d, value): def qdump__QImage(d, value):
if d.qtVersion() < 0x050000: if d.qtVersion() < 0x050000:
@@ -1024,7 +1024,7 @@ def qdump__QImage(d, value):
d.putType('void *') d.putType('void *')
displayFormat = d.currentItemFormat() displayFormat = d.currentItemFormat()
if displayFormat == SeparateFormat: if displayFormat == DisplayFormat.SeparateFormat:
d.putDisplay('imagedata:separate', '%08x%08x%08x%08x' % (width, height, nbytes, iformat) d.putDisplay('imagedata:separate', '%08x%08x%08x%08x' % (width, height, nbytes, iformat)
+ d.readMemory(bits, nbytes)) + d.readMemory(bits, nbytes))
@@ -1167,7 +1167,7 @@ def qdumpHelper_Qt5_QMap(d, value, keyType, valueType):
def qform__QMap(): def qform__QMap():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__QMap(d, value): def qdump__QMap(d, value):
qdumpHelper_QMap(d, value, value.type[0], value.type[1]) 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) qdumpHelper_Qt5_QMap(d, value, keyType, valueType)
def qform__QMultiMap(): def qform__QMultiMap():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__QMultiMap(d, value): def qdump__QMultiMap(d, value):
qdump__QMap(d, value) qdump__QMap(d, value)
def qform__QVariantMap(): def qform__QVariantMap():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__QVariantMap(d, value): def qdump__QVariantMap(d, value):
qdumpHelper_QMap(d, value, d.createType('QString'), d.createType('QVariant')) qdumpHelper_QMap(d, value, d.createType('QString'), d.createType('QVariant'))
@@ -1458,7 +1458,7 @@ def qdump__QSizePolicy(d, value):
def qform__QStack(): def qform__QStack():
return arrayForms() return [DisplayFormat.ArrayPlotFormat]
def qdump__QStack(d, value): def qdump__QStack(d, value):
qdump__QVector(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]) d.setValues(base, 'short', [ord(c) for c in data])
def qform__QString(): def qform__QString():
return [SimpleFormat, SeparateFormat] return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat]
def qdump__QString(d, value): def qdump__QString(d, value):
d.putStringValue(value) d.putStringValue(value)
(data, size, alloc) = d.stringData(value) (data, size, alloc) = d.stringData(value)
d.putNumChild(size) d.putNumChild(size)
displayFormat = d.currentItemFormat() displayFormat = d.currentItemFormat()
if displayFormat == SeparateFormat: if displayFormat == DisplayFormat.SeparateFormat:
d.putDisplay('utf16:separate', d.encodeString(value, limit=100000)) d.putDisplay('utf16:separate', d.encodeString(value, limit=100000))
if d.isExpanded(): if d.isExpanded():
d.putArrayData(data, size, d.createType('QChar')) d.putArrayData(data, size, d.createType('QChar'))
@@ -1596,7 +1596,7 @@ def qdump__QTextDocument(d, value):
def qform__QUrl(): def qform__QUrl():
return [SimpleFormat, SeparateFormat] return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat]
def qdump__QUrl(d, value): def qdump__QUrl(d, value):
privAddress = d.extractPointer(value) privAddress = d.extractPointer(value)
@@ -1637,7 +1637,7 @@ def qdump__QUrl(d, value):
d.putValue(url, 'utf16') d.putValue(url, 'utf16')
displayFormat = d.currentItemFormat() displayFormat = d.currentItemFormat()
if displayFormat == SeparateFormat: if displayFormat == DisplayFormat.SeparateFormat:
d.putDisplay('utf16:separate', url) d.putDisplay('utf16:separate', url)
d.putNumChild(1) d.putNumChild(1)
@@ -1851,7 +1851,7 @@ def qdump__QVariant(d, value):
d.putNumChild(0) d.putNumChild(0)
return None return None
#warn('TYPE: %s' % variantType) #DumperBase.warn('TYPE: %s' % variantType)
if variantType <= 86: if variantType <= 86:
# Known Core or Gui type. # Known Core or Gui type.
@@ -1867,15 +1867,15 @@ def qdump__QVariant(d, value):
#data = value['d']['data'] #data = value['d']['data']
innerType = d.qtNamespace() + innert innerType = d.qtNamespace() + innert
#warn('SHARED: %s' % isShared) #DumperBase.warn('SHARED: %s' % isShared)
if isShared: if isShared:
base1 = d.extractPointer(value) base1 = d.extractPointer(value)
#warn('BASE 1: %s %s' % (base1, innert)) #DumperBase.warn('BASE 1: %s %s' % (base1, innert))
base = d.extractPointer(base1) base = d.extractPointer(base1)
#warn('SIZE 1: %s' % size) #DumperBase.warn('SIZE 1: %s' % size)
val = d.createValue(base, innerType) val = d.createValue(base, innerType)
else: else:
#warn('DIRECT ITEM 1: %s' % innerType) #DumperBase.warn('DIRECT ITEM 1: %s' % innerType)
val = d.createValue(data, innerType) val = d.createValue(data, innerType)
val.laddress = value.laddress val.laddress = value.laddress
@@ -1939,7 +1939,7 @@ def qedit__QVector(d, value, data):
def qform__QVector(): def qform__QVector():
return arrayForms() return [DisplayFormat.ArrayPlotFormat]
def qdump__QVector(d, value): def qdump__QVector(d, value):
@@ -2053,17 +2053,17 @@ def qdump__QXmlStreamAttribute(d, value):
####################################################################### #######################################################################
def extractQmlData(d, value): def extractQmlData(d, value):
#if value.type.code == TypeCodePointer: #if value.type.code == TypeCode.TypeCodePointer:
# value = value.dereference() # value = value.dereference()
base = value.split('p')[0] base = value.split('p')[0]
#mmdata = d.split('Q', base)[0] #mmdata = d.split('Q', base)[0]
#PointerMask = 0xfffffffffffffffd #PointerMask = 0xfffffffffffffffd
#vtable = mmdata & PointerMask #vtable = mmdata & PointerMask
#warn('QML DATA: %s' % value.stringify()) #DumperBase.warn('QML DATA: %s' % value.stringify())
#data = value['data'] #data = value['data']
#return #data.cast(d.lookupType(value.type.name.replace('QV4::', 'QV4::Heap::'))) #return #data.cast(d.lookupType(value.type.name.replace('QV4::', 'QV4::Heap::')))
typeName = 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) return d.createValue(base, typeName)
def qdump__QV4__Heap__Base(d, value): 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) v = QV4_getValue(d, jsval)
if v: if v:
return v return v
warn('Not implemented: VARIANT') d.warn('Not implemented: VARIANT')
return 0 return 0
def QV4_putObjectValue(d, objectPtr): def QV4_putObjectValue(d, objectPtr):
@@ -2424,7 +2424,7 @@ def qdump_64__QV4__Value(d, value):
d.putBetterType('%sQV4::Value (object)' % ns) d.putBetterType('%sQV4::Value (object)' % ns)
#QV4_putObjectValue(d, d.extractPointer(value) + 2 * d.ptrSize()) #QV4_putObjectValue(d, d.extractPointer(value) + 2 * d.ptrSize())
arrayVTable = d.symbolAddress(ns + 'QV4::ArrayObject::static_vtbl') 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.putNumChild(1)
d.putItem(d.createValue(d.extractPointer(value) + 2 * d.ptrSize(), ns + 'QV4::Object')) d.putItem(d.createValue(d.extractPointer(value) + 2 * d.ptrSize(), ns + 'QV4::Object'))
return return
@@ -2630,7 +2630,7 @@ def qdump__QScriptValue(d, value):
payload = x['asBits']['payload'] payload = x['asBits']['payload']
#isValid = int(x['asBits']['tag']) != -6 # Empty #isValid = int(x['asBits']['tag']) != -6 # Empty
#isCell = int(x['asBits']['tag']) == -2 #isCell = int(x['asBits']['tag']) == -2
#warn('IS CELL: %s ' % isCell) #DumperBase.warn('IS CELL: %s ' % isCell)
#isObject = False #isObject = False
#className = 'UNKNOWN NAME' #className = 'UNKNOWN NAME'
#if isCell: #if isCell:
@@ -2648,7 +2648,7 @@ def qdump__QScriptValue(d, value):
# type = cell['m_structure']['m_typeInfo']['m_type'] # type = cell['m_structure']['m_typeInfo']['m_type']
# isObject = int(type) == 7 # ObjectType; # isObject = int(type) == 7 # ObjectType;
# className = 'UNKNOWN NAME' # className = 'UNKNOWN NAME'
#warn('IS OBJECT: %s ' % isObject) #DumperBase.warn('IS OBJECT: %s ' % isObject)
#inline bool JSCell::inherits(const ClassInfo* info) const #inline bool JSCell::inherits(const ClassInfo* info) const
#for (const ClassInfo* ci = classInfo(); ci; ci = ci->parentClass) { #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 * from dumper import *
def qform__std__array(): def qform__std__array():
return arrayForms() return [DisplayFormat.ArrayPlotFormat]
def qdump__std__array(d, value): def qdump__std__array(d, value):
size = value.type[1] size = value.type[1]
@@ -36,7 +37,7 @@ def qdump__std__array(d, value):
def qform__std____1__array(): def qform__std____1__array():
return arrayForms() return [DisplayFormat.ArrayPlotFormat]
def qdump__std____1__array(d, value): def qdump__std____1__array(d, value):
qdump__std__array(d, value) qdump__std__array(d, value)
@@ -260,7 +261,7 @@ def qdump__std____1__list(d, value):
d.putSubItem(i, val) d.putSubItem(i, val)
def qform__std__map(): def qform__std__map():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__std__map(d, value): def qdump__std__map(d, value):
if d.isQnxTarget() or d.isMsvcTarget(): if d.isQnxTarget() or d.isMsvcTarget():
@@ -334,7 +335,7 @@ def qdump__std____cxx1998__map(d, value):
qdump__std__map(d, value) qdump__std__map(d, value)
def qform__std__multimap(): def qform__std__multimap():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__std__multimap(d, value): def qdump__std__multimap(d, value):
return qdump__std__map(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) qdump__std____1__set(d, value)
def qform__std____1__map(): def qform__std____1__map():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__std____1__map(d, value): def qdump__std____1__map(d, value):
try: try:
@@ -574,7 +575,7 @@ def qdump__std____1__map(d, value):
d.putPairItem(i, pair, 'key', 'value') d.putPairItem(i, pair, 'key', 'value')
def qform__std____1__multimap(): def qform__std____1__multimap():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__std____1__multimap(d, value): def qdump__std____1__multimap(d, value):
qdump__std____1__map(d, value) qdump__std____1__map(d, value)
@@ -620,8 +621,8 @@ def qdump__std____1__stack(d, value):
d.putBetterType(value.type) d.putBetterType(value.type)
def qform__std__string(): def qform__std__string():
return [Latin1StringFormat, SeparateLatin1StringFormat, return [DisplayFormat.Latin1StringFormat, DisplayFormat.SeparateLatin1StringFormat,
Utf8StringFormat, SeparateUtf8StringFormat ] DisplayFormat.Utf8StringFormat, DisplayFormat.SeparateUtf8StringFormat ]
def qdump__std__string(d, value): def qdump__std__string(d, value):
qdumpHelper_std__string(d, value, d.createType("char"), d.currentItemFormat()) 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) d.putValue(value.value, value.encoding)
def qform__std__unordered_map(): def qform__std__unordered_map():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qform__std____debug__unordered_map(): def qform__std____debug__unordered_map():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__std__unordered_map(d, value): def qdump__std__unordered_map(d, value):
if d.isQnxTarget() or d.isMsvcTarget(): if d.isQnxTarget() or d.isMsvcTarget():
@@ -861,7 +862,7 @@ def qdump__std__unordered_set(d, value):
p = d.extractPointer(p + offset) p = d.extractPointer(p + offset)
def qform__std____1__unordered_map(): def qform__std____1__unordered_map():
return mapForms() return [DisplayFormat.CompactMapFormat]
def qdump__std____1__unordered_map(d, value): def qdump__std____1__unordered_map(d, value):
(size, _) = value["__table_"]["__p2_"].split("pp") (size, _) = value["__table_"]["__p2_"].split("pp")
@@ -916,7 +917,7 @@ def qdump__std____debug__unordered_multiset(d, value):
def qform__std__valarray(): def qform__std__valarray():
return arrayForms() return [DisplayFormat.ArrayPlotFormat]
def qdump__std__valarray(d, value): def qdump__std__valarray(d, value):
if d.isMsvcTarget(): if d.isMsvcTarget():
@@ -928,7 +929,7 @@ def qdump__std__valarray(d, value):
def qform__std____1__valarray(): def qform__std____1__valarray():
return arrayForms() return [DisplayFormat.ArrayPlotFormat]
def qdump__std____1__valarray(d, value): def qdump__std____1__valarray(d, value):
innerType = value.type[0] innerType = value.type[0]
@@ -939,7 +940,7 @@ def qdump__std____1__valarray(d, value):
def qform__std__vector(): def qform__std__vector():
return arrayForms() return [DisplayFormat.ArrayPlotFormat]
def qedit__std__vector(d, value, data): def qedit__std__vector(d, value, data):
import gdb import gdb
@@ -1036,13 +1037,13 @@ def qdumpHelper__std__vector__QNX(d, value):
d.putPlotData(start, size, innerType) d.putPlotData(start, size, innerType)
def qform__std____1__vector(): def qform__std____1__vector():
return arrayForms() return [DisplayFormat.ArrayPlotFormat]
def qdump__std____1__vector(d, value): def qdump__std____1__vector(d, value):
qdumpHelper__std__vector(d, value, True) qdumpHelper__std__vector(d, value, True)
def qform__std____debug__vector(): def qform__std____debug__vector():
return arrayForms() return [DisplayFormat.ArrayPlotFormat]
def qdump__std____debug__vector(d, value): def qdump__std____debug__vector(d, value):
qdump__std__vector(d, value) qdump__std__vector(d, value)
@@ -1088,7 +1089,7 @@ def qdump__string(d, value):
qdump__std__string(d, value) qdump__std__string(d, value)
def qform__std__wstring(): def qform__std__wstring():
return [SimpleFormat, SeparateFormat] return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat]
def qdump__std__wstring(d, value): def qdump__std__wstring(d, value):
qdumpHelper_std__string(d, value, d.createType('wchar_t'), d.currentItemFormat()) 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": elif innerType == "wchar_t":
qdump__std____1__wstring(d, value) qdump__std____1__wstring(d, value)
else: else:
warn("UNKNOWN INNER TYPE %s" % innerType) d.warn("UNKNOWN INNER TYPE %s" % innerType)
def qdump__wstring(d, value): def qdump__wstring(d, value):
qdump__std__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")