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)