def iterdump_Block_static_ofFrame_curr():
from _common import iterdump_Block
fr = gdb.selected_frame()
if not fr: _common.die('No frame selected.')
b = fr.block().static_block
if not b: _common.die('No static block.')
iterdump_Block(b)
def assertArity(argv, expected_argn):
actual_argn = len(argv)
if actual_argn != expected_argn:
_common.die(
sprintf('Given %u argument%s, but command expects %u.',
actual_argn, ternary(1 == actual_argn, '',
's'), expected_argn))
def iterdump_Block_global_ofFrame_curr():
from _common import iterdump_Block
fr = gdb.selected_frame()
if not fr: _common.die('No frame selected.')
b = fr.block().global_block
if not b: _common.die('No global block.')
iterdump_Block(b)
def dump_all_frames():
from _common import list_all_Frame, dump_Frame
aF = list_all_Frame()
for i_fr in range(len(aF)):
dump_Frame(i_fr, aF[i_fr])
if i_fr >= MAX_NEST_DUMP_DEPTH.const:
_common.die('Halt, max dump depth.')
def wrap__iterdump_Type_withAnonFields(s):
from _common import iterdump_Type, stripEnclosing_quoteMarks
s = stripEnclosing_quoteMarks(s)
try:
t = gdb.lookup_type(s)
iterdump_Type(t, deep_items(t))
except BaseException as e:
_common.die('No such type?')
def invoke(self, argsAsOneString, isFromTTY):
s = prep__single_nonValue_string(argsAsOneString)
t = None
try:
t = gdb.lookup_type(s)
except BaseException as whatev:
_common.die('Cannot discern a type from input.')
impl__type(t)
def invoke(self, argsAsOneString, isFromTTY):
s = prep__single_nonValue_string(argsAsOneString)
try:
t = gdb.lookup_type(s)
tNamePrecis = impl__type_nameOnly(t)
printf__toStdout('%s\n', tNamePrecis)
except BaseException as e:
_common.die('Cannot discern a type from input.')
def get_set_string(self):
from _common import die
global PREF_PrintWidth_MemberName
n = int(self.value)
if n < 5:
die('May not be less than 5.')
PREF_PrintWidth_MemberName = n
_reloader.reload_all_but_preferences()
return ''
def getElement(self, lookupBy):
s = str(lookupBy)
if s.isdecimal(): i = int(lookupBy)
else: i = self.indexAlternatively(s)
assert_uint(i)
if i >= self.nElements:
die('Out-of-bounds: =[=%u=]= >= =[=%u=]= = size.' %
(i, self.nElements))
return self.printables[i]
def invoke(self, argsAsOneString, isFromTTY):
s = prep__single_nonValue_string(argsAsOneString)
find_rv = find_ValueSymbolFrameBlock(s)
v = find_rv[0]
symb_lookup_rv = find_rv[1]
b = find_rv[3]
if (None == v):
_common.die('Unusable input.')
impl__type(v.type, v)
def invoke(self, argsAsOneString, isFromTTY):
aggreg_v = prep__single_gdbValue(argsAsOneString)
aggreg_ppObj = mk__aggreg_ppObj(aggreg_v)
if isinstance(aggreg_ppObj, HashtabAssociativePP):
aggreg_ppObj.printBucketwise()
else:
_common.die(
'Neither std::unordered_map nor std::unordered_set; inapplicable.'
)
def mk__iter_ppObj(v, aboutTag=''):
aboutStr = mk_aboutStr(aboutTag)
iterHusk = _stl_iterators.unwrap_iteratorValue(v)
v_using = nonNull(iterHusk.coreValue, v)
(ppClass, dummy) = _stl_iterators.getPP(v_using.type,
try__unwrapType=False)
if not ppClass:
tStr = impl__type_nameOnly(v.type)
_common.die('%sType =[=%s=]= is not an iterator.' % (aboutStr, tStr))
return ppClass(v_using)
def getElementAddress(self, lookupBy):
s = str(lookupBy)
if s.isdecimal(): i = int(lookupBy)
else: i = self.indexAlternatively(s)
assert_uint(i)
if i >= self.nElements:
die('Out-of-bounds: =[=%u=]= >= =[=%u=]= = size.' %
(i, self.nElements))
if 0 == len(self.elemAddrs):
raise PPFault('Elem addresses not collected; BUG?')
return self.elemAddrs[i]
def getElement(self, key):
assert self.stringformKeys != None
if self.keysOnly:
for i in range(0, self.nElements, 1):
if self.sameAs(key, self.printables[i][1]):
return self.printables[i]
else:
for i in range(0, self.nElements * 2, 2):
if self.sameAs(key, self.printables[i][1]):
return self.printables[i + 1]
die('Found no element keyed by =[=%s=]=', str(key))
def prep__aggregObj_and_lookupBy(argsAsOneString, lookupBy_key_only=False):
from _common import stripEnclosing_quoteMarks
argv = gdb.string_to_argv(argsAsOneString)
assertArity(argv, 2)
lookupBy = stripEnclosing_quoteMarks(argv[-1])
aggreg_v = gdb.parse_and_eval(argv[-2])
aggreg_ppObj = mk__aggreg_ppObj(aggreg_v, 'first arg')
if lookupBy_key_only and not isinstance(aggreg_ppObj, AssociativePP):
_common.die(
'%sType =[=%s=]= does not support key lookup.' %
(mk_aboutStr('first arg'), impl__type_nameOnly(aggreg_v.type)))
return (aggreg_ppObj, lookupBy)
def getElementKeyAddress(self, key):
assert self.stringformKeys != None
if self.keysOnly:
for i in range(0, self.nElements, 1):
if self.sameAs(key, self.printables[i][1]):
return self.keyAddrs[i]
else:
for i in range(0, self.nElements * 2,
2): # Must use "//" when dividing integers.
if self.sameAs(key, self.printables[i][1]):
return self.keyAddrs[i // 2]
die('Found no element keyed by =[=%s=]=' % (str(key)))
def mk__aggreg_ppObj(v, aboutTag=''):
aboutStr = mk_aboutStr(aboutTag)
ppClass = _stl_containers.getPP(v.type)
if not ppClass:
ppClass = _stl_utilities.getPP(v.type)
if ppClass and not issubclass(ppClass, AggregatePP):
tStr = impl__type_nameOnly(v.type)
_common.die('%sType =[=%s=]= is not an aggregate.' % (aboutStr, tStr))
if not ppClass:
tStr = impl__type_nameOnly(v.type)
_common.die('%sType =[=%s=]= is not an applicable type.' %
(aboutStr, tStr))
return ppClass(v)
def mk__indirector_ppObj(v, aboutTag=''):
aboutStr = mk_aboutStr(aboutTag)
ppClass = _stl_iterators.getPP(v.type)
if not ppClass:
ppClass = _stl_utilities.getPP(v.type)
if ppClass and not issubclass(ppClass, IndirectorPP):
tStr = impl__type_nameOnly(v.type)
_common.die('%sType =[=%s=]= is neither iterator nor smart pointer.' %
(aboutStr, tStr))
if not ppClass:
tStr = impl__type_nameOnly(v.type)
_common.die('%sType =[=%s=]= is not an applicable type.' %
(aboutStr, tStr))
return ppClass(v)
def iterdump_Block_ofFrame_N(j_fr):
if not is_uint(j_fr):
_common.die('Argument is not a valid frame #.')
from _common import list_all_Frame, iterdump_Block
aF = list_all_Frame()
for i_fr in range(len(aF)):
if i_fr != j_fr:
continue
fr = aF[i_fr]
b = fr.block()
iterdump_Block(b)
return
_common.die(
'No frame with so high a number; check "backtrace past-main" and "backtrace past-entry" parameters?'
)
def dump_blocks_from_deepest_out():
fr = gdb.selected_frame()
if not fr: _common.die('No frame selected.')
from _common import dump_Block
b = fr.block()
stal = fr.find_sal() # Surely correct for the *first* Block.
i_block = 0
while b != None:
if i_block > 0 and not b.is_static and not b.is_global:
stalOther = gdb.find_pc_line(b.start)
if stalOther != None:
stal = stalOther
dump_Block(b, stal)
b = b.superblock
if i_block >= MAX_NEST_DUMP_DEPTH.const:
_common.die('Halt, max dump depth.')
i_block += 1
def iterdump_Objfile(objfileName):
x = None
try:
x = gdb.lookup_objfile(objfileName)
except ValueError as err:
pass
if not x:
_common.die('None such.')
printf('Objfile {\n')
for k, v in x.__dict__:
printf('\t%s --> %s\n', str(k), str(v))
printf('}\n')
y = x.progspace
if not y:
_common.die('No progspace associated.')
printf('\nProgspace {\n')
for k, v in y.__dict__:
printf('\t%s --> %s\n', str(k), str(v))
printf('}\n')
def invoke(self, argsAsOneString, isFromTTY):
s = prep__single_nonValue_string(argsAsOneString)
haveType = False
mustBeValue = False
for c in s:
if not (c.isidentifier() or (c == ':')):
mustBeValue = True
break
if not mustBeValue:
try:
t = gdb.lookup_type(s)
haveType = True
except BaseException as whatev:
mustBeValue = True
if not haveType or mustBeValue:
v = parseAndEval(s)
if (v == None):
_common.die('Cannot discern a type from input.')
t = v.type
impl__type(t)
def invoke(self, argsAsOneString, isFromTTY):
from _our_p import impl__afar, wrap__valueProper
s = prep__single_nonValue_string(argsAsOneString)
find_rv = find_ValueSymbolFrameBlock(s)
v = find_rv[0]
symb_lookup_rv = find_rv[1]
fr = find_rv[2]
b = find_rv[3]
if (v != None
) or symb_lookup_rv or b: # Just fr, on its own, is not worthwile.
impl__afar(v, symb_lookup_rv, fr, b)
else:
_common.die('Unusable input.')
if (v != None):
indents = _indent_spec.IndentSpec(2)
indents.newLine_misc()
wrap__valueProper(v, indents)
printf('\n')
else: # **Can** control reach here?
_common.die('Cannot find symbol.')
def mk__anyRecognized_ppObj(v):
import _pp_base_classes
from _common import gdbType_to_ppClass
# We shall unwrap the iterator (if iterator) ourselves later;
# because we need to unwrap *value*, and gdbType_to_ppClass()
# calls _stl_iterators.getPP() which calls unwrap_iteratorType().
(ppClass, dummy) = _common.gdbType_to_ppClass(v.type, True)
if not ppClass:
tStr = impl__type_nameOnly(v.type)
_common.die('Type =[=%s=]= is not a supported STL type.' % (tStr))
if issubclass(ppClass, _pp_base_classes.IteratorPP):
iterHusk = unwrap_iteratorValue(v)
if iterHusk.coreType != None:
(ppClass_other,
dummy) = _stl_iterators.getPP(iterHusk.coreType, False)
ppObj = ppClass_other(iterHusk.coreValue)
if iterHusk.any_moveWrappers:
ppObj.noteMisc('std::move_iterator adapter wrapped.')
if iterHusk.any_reverseWrappers:
ppObj.noteMisc('std::reverse_iterator adapter wrapped.')
return ppObj
#
ppObj = ppClass(v)
return ppObj
def wrap__iterdump_SymtabLinetab_curr():
from _common import prAddr, iterdump_LineTable
fr = gdb.selected_frame()
printf('Frame name="%s" pc=%s type=%s\n', fr.name(), prAddr(fr.pc()),
frame_typeToStr[fr.type()])
stal = fr.find_sal()
if not stal or not stal.is_valid():
_common.die('Bad stal')
printf('Symtab_and_line line=%d pc=%s last=%s\n', stal.line,
prAddr(stal.pc), prAddr(stal.last))
stab = stal.symtab
if not stab or not stab.is_valid():
_common.die('Bad stab')
printf('Symtab filename="%s" fullname="%s"\n', stab.filename,
stab.fullname())
objf = stab.objfile
if objf:
printf('Objfile filename="%s"\n', objf.filename)
ltab = stab.linetable()
if not ltab or not ltab.is_valid():
_common.die('Bad ltab')
b = fr.block()
iterdump_LineTable(ltab, b.start, b.end) #stal.pc, stal.last)
def indexAlternatively(self, lookupBy): # Subclasses may override.
die('Asked to lookup by other than nonnegative integer.')
def getTargetAddress(self):
if None == self.targetAddr:
die('Object points to/manages nothing.')
return self.targetAddr
def iterdump_Block_curr():
from _common import iterdump_Block
fr = gdb.selected_frame()
if not fr: _common.die('No frame selected.')
b = fr.block()
iterdump_Block(b)
