def __lldb_init_module(debugger,dict): debugger.CreateCategory("JASSynth").AddTypeSynthetic(lldb.SBTypeNameSpecifier("JustAStruct"), lldb.SBTypeSynthetic.CreateWithClassName("synth.jasSynthProvider")) cat = lldb.debugger.CreateCategory("CCCSynth") cat.AddTypeSynthetic( lldb.SBTypeNameSpecifier("CCC"), lldb.SBTypeSynthetic.CreateWithClassName("synth.CCCSynthProvider", lldb.eTypeOptionCascade)) cat.AddTypeSummary( lldb.SBTypeNameSpecifier("CCC"), lldb.SBTypeSummary.CreateWithFunctionName("synth.ccc_summary", lldb.eTypeOptionCascade))
def test_with_run_command(self): """Test that LLDB correctly cleans caches when language categories change.""" # This is the function to remove the custom formats in order to have a # clean slate for the next test case. def cleanup(): if hasattr(self, 'type_category') and hasattr(self, 'type_specifier'): self.type_category.DeleteTypeSummary(self.type_specifier) # Execute the cleanup function during test case tear down. self.addTearDownHook(cleanup) self.build() self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self.runCmd("run", RUN_SUCCEEDED) # The stop reason of the thread should be breakpoint. self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs = ['stopped', 'stop reason = breakpoint']) self.expect("frame variable", substrs = ['(S)', 'object', '123', '456'], matching=True) self.type_category = self.dbg.GetCategory(lldb.eLanguageTypeC_plus_plus) type_summary = lldb.SBTypeSummary.CreateWithSummaryString("this is an object of type S") self.type_specifier = lldb.SBTypeNameSpecifier('S') self.type_category.AddTypeSummary(self.type_specifier, type_summary) self.expect("frame variable", substrs = ['this is an object of type S'], matching=True) self.type_category.DeleteTypeSummary(self.type_specifier) self.expect("frame variable", substrs = ['this is an object of type S'], matching=False) self.expect("frame variable", substrs = ['(S)', 'object', '123', '456'], matching=True)
def __lldb_init_module(debugger, *rest): print "registering QString" summary = lldb.SBTypeSummary.CreateWithFunctionName( "qstring.utf16string_summary") summary.SetOptions(lldb.eTypeOptionHideChildren) debugger.GetDefaultCategory().AddTypeSummary( lldb.SBTypeNameSpecifier("QString", False), summary)
def attach_summary_to_type(summary_fn, type_name, is_regex=False): global rust_category summary = lldb.SBTypeSummary.CreateWithFunctionName( 'adapter.formatters.rust.' + summary_fn) summary.SetOptions(lldb.eTypeOptionCascade) assert rust_category.AddTypeSummary( lldb.SBTypeNameSpecifier(type_name, is_regex), summary)
def attach_synthetic_to_type(synth_class, type_name, is_regex=False): global rust_category synth = lldb.SBTypeSynthetic.CreateWithClassName( 'adapter.formatters.rust.' + synth_class) synth.SetOptions(lldb.eTypeOptionCascade) assert rust_category.AddTypeSynthetic( lldb.SBTypeNameSpecifier(type_name, is_regex), synth)
def attach_summary_to_type(summary_fn, type_name, is_regex=False): global module, rust_category #log.debug('attaching summary %s to "%s", is_regex=%s', summary_fn.__name__, type_name, is_regex) summary = lldb.SBTypeSummary.CreateWithFunctionName(__name__ + '.' + summary_fn.__name__) summary.SetOptions(lldb.eTypeOptionCascade) rust_category.AddTypeSummary(lldb.SBTypeNameSpecifier(type_name, is_regex), summary)
def register_pretty_printer(obj, printer): gdb.pretty_printers.append(printer) if lldb.debugger.GetCategory(printer.name).IsValid(): print('WARNING: A type category with name "%s" already exists.' % printer.name) return cat = lldb.debugger.CreateCategory(printer.name) type_options = (lldb.eTypeOptionCascade | lldb.eTypeOptionSkipPointers | lldb.eTypeOptionSkipReferences | lldb.eTypeOptionHideEmptyAggregates) for sp in printer.subprinters: cat.AddTypeSummary( lldb.SBTypeNameSpecifier('^%s(<.+>)?(( )?&)?$' % sp.name, True), lldb.SBTypeSummary.CreateWithFunctionName( 'gdb.printing.type_summary_function', type_options)) cat.AddTypeSynthetic( lldb.SBTypeNameSpecifier('^%s(<.+>)?(( )?&)?$' % sp.name, True), lldb.SBTypeSynthetic.CreateWithClassName( 'gdb.printing.GdbPrinterSynthProvider', type_options)) cat.SetEnabled(True)
def attach_synthetic_to_type(synth_class, type_name, is_regex=False): global module, d_category synth = lldb.SBTypeSynthetic.CreateWithClassName(__name__ + '.' + synth_class.__name__) synth.SetOptions(lldb.eTypeOptionCascade) ret = d_category.AddTypeSynthetic(lldb.SBTypeNameSpecifier(type_name, is_regex), synth) log.debug('attaching synthetic %s to "%s", is_regex=%s -> %s', synth_class.__name__, type_name, is_regex, ret) summary_fn = lambda valobj, dict: get_synth_summary(synth_class, valobj, dict) # LLDB accesses summary fn's by name, so we need to create a unique one. summary_fn.__name__ = '_get_synth_summary_' + synth_class.__name__ setattr(module, summary_fn.__name__, summary_fn) attach_summary_to_type(summary_fn, type_name, is_regex)
def attach_synthetic_to_type(synth_class, type_name, is_regex=False): global rust_category global module synth = lldb.SBTypeSynthetic.CreateWithClassName('adapter.formatters.rust.' + synth_class.__name__) synth.SetOptions(lldb.eTypeOptionCascade) rust_category.AddTypeSynthetic(lldb.SBTypeNameSpecifier(type_name, is_regex), synth) summary_fn = lambda valobj, dict: get_synth_summary(synth_class, valobj, dict) # LLDB accesses summary fn's by name, so we need to create a unique one. summary_fn.__name__ = '_get_synth_summary_' + synth_class.__name__ setattr(module, summary_fn.__name__, summary_fn) attach_summary_to_type(summary_fn, type_name, is_regex)
def attach(enoki_category, synth_class, type_name, summary=True, synth=True): if summary: def summary_func(instance, internal_dict): synth = synth_class(instance.GetNonSyntheticValue(), internal_dict) synth.update() return synth.get_summary() summary_func.__name__ = synth_class.__name__ + 'SummaryWrapper' setattr(sys.modules[__name__], summary_func.__name__, summary_func) summary = lldb.SBTypeSummary.CreateWithFunctionName( __name__ + '.' + summary_func.__name__) summary.SetOptions(lldb.eTypeOptionCascade) enoki_category.AddTypeSummary( lldb.SBTypeNameSpecifier(type_name, True), summary) if synth: synth = lldb.SBTypeSynthetic.CreateWithClassName(__name__ + '.' + synth_class.__name__) synth.SetOptions(lldb.eTypeOptionCascade) enoki_category.AddTypeSynthetic( lldb.SBTypeNameSpecifier(type_name, True), synth)
def attach_synthetic_to_type(synth_class, type_name, is_regex=False): global module, boltzmann_solver_category synth: lldb.SBTypeSynthetic = lldb.SBTypeSynthetic.CreateWithClassName( __name__ + "." + synth_class.__name__) synth.SetOptions(lldb.eTypeOptionCascade) boltzmann_solver_category.AddTypeSynthetic( lldb.SBTypeNameSpecifier(type_name, is_regex), synth) def summary_fn(valobj, dict): return get_synth_summary(synth_class, valobj, dict) # LLDB accesses summary fn's by name, so we need to create a unique one. summary_fn.__name__ = "_get_synth_summary_" + synth_class.__name__ setattr(module, summary_fn.__name__, summary_fn) attach_summary_to_type(summary_fn, type_name, is_regex)
def __lldb_init_module(debugger, dict): clearLog() log('********************************** init module 3') category = debugger.GetDefaultCategory() for type in ['uString', 'uObject', 'uType', 'uArray']: summary = lldb.SBTypeSummary.CreateWithFunctionName(moduleName + '.' + type + 'Summary') isRegex = False debugger.GetDefaultCategory().AddTypeSummary( lldb.SBTypeNameSpecifier(type, isRegex), summary) for type in ['uStrong', 'uSStrong', 'uWeak', 'uSWeak']: summary = lldb.SBTypeSummary.CreateWithFunctionName( moduleName + '.firstChildSummary') isRegex = True category.AddTypeSummary( lldb.SBTypeNameSpecifier(type + '<.*>', isRegex), summary) synthetic = lldb.SBTypeSynthetic.CreateWithClassName( moduleName + '.FirstChildSynthProvider') synthetic.SetOptions(lldb.eTypeOptionCascade) category.AddTypeSynthetic( lldb.SBTypeNameSpecifier(type + '<.*>', isRegex), synthetic) summary = lldb.SBTypeSummary.CreateWithFunctionName(moduleName + '.uObjectSummary') isRegex = True category.AddTypeSummary(lldb.SBTypeNameSpecifier('g::.+', isRegex), summary) synthetic = lldb.SBTypeSynthetic.CreateWithClassName( moduleName + '.UObjectSynthProvider') synthetic.SetOptions(lldb.eTypeOptionCascade) category.AddTypeSynthetic(lldb.SBTypeNameSpecifier('uObject', False), synthetic) synthetic = lldb.SBTypeSynthetic.CreateWithClassName( moduleName + '.UObjectSynthProvider') synthetic.SetOptions(lldb.eTypeOptionCascade) category.AddTypeSynthetic(lldb.SBTypeNameSpecifier('g::.+', True), synthetic) synthetic = lldb.SBTypeSynthetic.CreateWithClassName( moduleName + '.UArraySynthProvider') synthetic.SetOptions(lldb.eTypeOptionCascade) category.AddTypeSynthetic(lldb.SBTypeNameSpecifier('uArray', False), synthetic)
def use_function(function): jni_category = lldb.debugger.CreateCategory("JNI types") jstring_summary = lldb.SBTypeSummary.CreateWithFunctionName(function) jni_category.AddTypeSummary(lldb.SBTypeNameSpecifier("jstring"), jstring_summary) jni_category.SetEnabled(True)
def __lldb_init_module(debugger, internal_dict): lldb.formatters.Logger._lldb_formatters_debug_level = 2 category = debugger.GetDefaultCategory() category.SetEnabled(True) category.AddTypeSummary(lldb.SBTypeNameSpecifier("NI8"), \ lldb.SBTypeSummary.CreateWithFunctionName('lldbnim.NimNI8_SummaryFormatter')) category.AddTypeSummary(lldb.SBTypeNameSpecifier("NU8"), \ lldb.SBTypeSummary.CreateWithFunctionName('lldbnim.NimNU_SummaryFormatter')) category.AddTypeSummary(lldb.SBTypeNameSpecifier("NU16"), \ lldb.SBTypeSummary.CreateWithFunctionName('lldbnim.NimNU_SummaryFormatter')) category.AddTypeSummary(lldb.SBTypeNameSpecifier("NU32"), \ lldb.SBTypeSummary.CreateWithFunctionName('lldbnim.NimNU_SummaryFormatter')) category.AddTypeSummary(lldb.SBTypeNameSpecifier("NU64"), \ lldb.SBTypeSummary.CreateWithFunctionName('lldbnim.NimNU_SummaryFormatter')) category.AddTypeSummary(lldb.SBTypeNameSpecifier("^tyEnum_.*$", True), \ lldb.SBTypeSummary.CreateWithFunctionName('lldbnim.NimEnum_SummaryFormatter')) category.AddTypeSynthetic( \ lldb.SBTypeNameSpecifier("NimStringDesc"), \ lldb.SBTypeSynthetic.CreateWithClassName("lldbnim.NimSeqProvider", lldb.eTypeOptionCascade)) category.AddTypeSummary(lldb.SBTypeNameSpecifier('NimStringDesc'), \ lldb.SBTypeSummary.CreateWithFunctionName('lldbnim.NimStringDesc_SummaryFormatter')) category.AddTypeSynthetic( \ lldb.SBTypeNameSpecifier("^tySequence__.*$", True), \ lldb.SBTypeSynthetic.CreateWithClassName("lldbnim.NimSeqProvider", lldb.eTypeOptionCascade)) category.AddTypeSummary( \ lldb.SBTypeNameSpecifier("^tySequence__.*$", True), \ lldb.SBTypeSummary.CreateWithFunctionName('lldbnim.NimSeq_SummaryFormatter')) category.AddTypeSummary( \ lldb.SBTypeNameSpecifier("^tyArray__.*$", True), \ lldb.SBTypeSummary.CreateWithFunctionName('lldbnim.NimArray_SummaryFormatter')) category.AddTypeSynthetic( \ lldb.SBTypeNameSpecifier("^tyObject_Table__.*$", True), \ lldb.SBTypeSynthetic.CreateWithClassName("lldbnim.NimTableProvider", lldb.eTypeOptionCascade)) category.AddTypeSummary( \ lldb.SBTypeNameSpecifier("^tyObject_Table__.*$", True), \ lldb.SBTypeSummary.CreateWithFunctionName('lldbnim.NimTable_SummaryFormatter'))
def __lldb_init_module(debugger, dict): debugger.CreateCategory("JASSynth").AddTypeSynthetic( lldb.SBTypeNameSpecifier("JustAStruct"), lldb.SBTypeSynthetic.CreateWithClassName("jas_synth.jasSynthProvider"))
def test_formatters_api(self): """Test Python APIs for working with formatters""" self.build() self.setTearDownCleanup() """Test Python APIs for working with formatters""" self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) lldbutil.run_break_set_by_file_and_line( self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) self.runCmd("run", RUN_SUCCEEDED) # The stop reason of the thread should be breakpoint. self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs=['stopped', 'stop reason = breakpoint']) # This is the function to remove the custom formats in order to have a # clean slate for the next test case. def cleanup(): self.runCmd('type format clear', check=False) self.runCmd('type summary clear', check=False) self.runCmd('type filter clear', check=False) self.runCmd('type synthetic clear', check=False) self.runCmd('type category delete foobar', check=False) self.runCmd('type category delete JASSynth', check=False) self.runCmd('type category delete newbar', check=False) # Execute the cleanup function during test case tear down. self.addTearDownHook(cleanup) format = lldb.SBTypeFormat(lldb.eFormatHex) category = self.dbg.GetDefaultCategory() category.AddTypeFormat(lldb.SBTypeNameSpecifier("int"), format) self.expect("frame variable foo.A", substrs=['0x00000001']) self.expect("frame variable foo.E", matching=False, substrs=['b8cca70a']) category.AddTypeFormat(lldb.SBTypeNameSpecifier("long"), format) self.expect("frame variable foo.A", substrs=['0x00000001']) self.expect("frame variable foo.E", substrs=['b8cca70a']) format.SetFormat(lldb.eFormatOctal) category.AddTypeFormat(lldb.SBTypeNameSpecifier("int"), format) self.expect("frame variable foo.A", substrs=[' 01']) self.expect("frame variable foo.E", substrs=['b8cca70a']) category.DeleteTypeFormat(lldb.SBTypeNameSpecifier("int")) category.DeleteTypeFormat(lldb.SBTypeNameSpecifier("long")) self.expect("frame variable foo.A", matching=False, substrs=[' 01']) self.expect("frame variable foo.E", matching=False, substrs=['b8cca70a']) summary = lldb.SBTypeSummary.CreateWithSummaryString( "the hello world you'll never see") summary.SetSummaryString('hello world') new_category = self.dbg.GetCategory("foobar") self.assertFalse( new_category.IsValid(), "getting a non-existing category worked") new_category = self.dbg.CreateCategory("foobar") new_category.SetEnabled(True) new_category.AddTypeSummary( lldb.SBTypeNameSpecifier( "^.*t$", True, # is_regexp ), summary) self.expect("frame variable foo.A", substrs=['hello world']) self.expect("frame variable foo.E", matching=False, substrs=['hello world']) self.expect("frame variable foo.B", substrs=['hello world']) self.expect("frame variable foo.F", substrs=['hello world']) new_category.SetEnabled(False) self.expect("frame variable foo.A", matching=False, substrs=['hello world']) self.expect("frame variable foo.E", matching=False, substrs=['hello world']) self.expect("frame variable foo.B", matching=False, substrs=['hello world']) self.expect("frame variable foo.F", matching=False, substrs=['hello world']) self.dbg.DeleteCategory(new_category.GetName()) self.expect("frame variable foo.A", matching=False, substrs=['hello world']) self.expect("frame variable foo.E", matching=False, substrs=['hello world']) self.expect("frame variable foo.B", matching=False, substrs=['hello world']) self.expect("frame variable foo.F", matching=False, substrs=['hello world']) filter = lldb.SBTypeFilter(0) filter.AppendExpressionPath("A") filter.AppendExpressionPath("D") self.assertEqual( filter.GetNumberOfExpressionPaths(), 2, "filter with two items does not have two items") category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter) self.expect("frame variable foo", substrs=['A = 1', 'D = 6.28']) self.expect("frame variable foo", matching=False, substrs=['B = ', 'C = ', 'E = ', 'F = ']) category.DeleteTypeFilter( lldb.SBTypeNameSpecifier( "JustAStruct", True)) self.expect("frame variable foo", substrs=['A = 1', 'D = 6.28']) self.expect("frame variable foo", matching=False, substrs=['B = ', 'C = ', 'E = ', 'F = ']) category.DeleteTypeFilter( lldb.SBTypeNameSpecifier( "JustAStruct", False)) self.expect("frame variable foo", substrs=['A = 1', 'D = 6.28']) self.expect("frame variable foo", matching=True, substrs=['B = ', 'C = ', 'E = ', 'F = ']) self.runCmd("command script import --allow-reload ./synth.py") self.expect("frame variable foo", matching=False, substrs=['X = 1']) self.dbg.GetCategory("JASSynth").SetEnabled(True) self.expect("frame variable foo", matching=True, substrs=['X = 1']) self.dbg.GetCategory("CCCSynth").SetEnabled(True) self.expect( "frame variable ccc", matching=True, substrs=[ 'CCC object with leading value (int) a = 111', 'a = 111', 'b = 222', 'c = 333']) foo_var = self.dbg.GetSelectedTarget().GetProcess( ).GetSelectedThread().GetSelectedFrame().FindVariable('foo') self.assertTrue(foo_var.IsValid(), 'could not find foo') self.assertTrue( foo_var.GetDeclaration().IsValid(), 'foo declaration is invalid') self.assertEqual( foo_var.GetNumChildren(), 2, 'synthetic value has wrong number of child items (synth)') self.assertEqual( foo_var.GetChildMemberWithName('X').GetValueAsUnsigned(), 1, 'foo_synth.X has wrong value (synth)') self.assertFalse( foo_var.GetChildMemberWithName('B').IsValid(), 'foo_synth.B is valid but should not (synth)') self.dbg.GetCategory("JASSynth").SetEnabled(False) foo_var = self.dbg.GetSelectedTarget().GetProcess( ).GetSelectedThread().GetSelectedFrame().FindVariable('foo') self.assertTrue(foo_var.IsValid(), 'could not find foo') self.assertFalse( foo_var.GetNumChildren() == 2, 'still seeing synthetic value') filter = lldb.SBTypeFilter(0) filter.AppendExpressionPath("A") filter.AppendExpressionPath("D") category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter) self.expect("frame variable foo", substrs=['A = 1', 'D = 6.28']) foo_var = self.dbg.GetSelectedTarget().GetProcess( ).GetSelectedThread().GetSelectedFrame().FindVariable('foo') self.assertTrue(foo_var.IsValid(), 'could not find foo') self.assertEqual( foo_var.GetNumChildren(), 2, 'synthetic value has wrong number of child items (filter)') self.assertEqual( foo_var.GetChildMemberWithName('X').GetValueAsUnsigned(), 0, 'foo_synth.X has wrong value (filter)') self.assertEqual( foo_var.GetChildMemberWithName('A').GetValueAsUnsigned(), 1, 'foo_synth.A has wrong value (filter)') self.assertTrue(filter.ReplaceExpressionPathAtIndex( 0, "C"), "failed to replace an expression path in filter") self.expect("frame variable foo", substrs=['A = 1', 'D = 6.28']) category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter) self.expect("frame variable foo", substrs=["C = 'e'", 'D = 6.28']) category.AddTypeFilter(lldb.SBTypeNameSpecifier("FooType"), filter) filter.ReplaceExpressionPathAtIndex(1, "F") self.expect("frame variable foo", substrs=["C = 'e'", 'D = 6.28']) category.AddTypeFilter(lldb.SBTypeNameSpecifier("JustAStruct"), filter) self.expect("frame variable foo", substrs=["C = 'e'", 'F = 0']) self.expect("frame variable bar", substrs=["C = 'e'", 'D = 6.28']) foo_var = self.dbg.GetSelectedTarget().GetProcess( ).GetSelectedThread().GetSelectedFrame().FindVariable('foo') self.assertTrue(foo_var.IsValid(), 'could not find foo') self.assertEqual( foo_var.GetChildMemberWithName('C').GetValueAsUnsigned(), ord('e'), 'foo_synth.C has wrong value (filter)') chosen = self.dbg.GetFilterForType( lldb.SBTypeNameSpecifier("JustAStruct")) self.assertEqual( chosen.count, 2, "wrong filter found for JustAStruct") self.assertEqual( chosen.GetExpressionPathAtIndex(0), 'C', "wrong item at index 0 for JustAStruct") self.assertEqual( chosen.GetExpressionPathAtIndex(1), 'F', "wrong item at index 1 for JustAStruct") self.assertFalse( category.DeleteTypeFilter( lldb.SBTypeNameSpecifier("NoSuchType")), "deleting a non-existing filter worked") self.assertFalse( category.DeleteTypeSummary( lldb.SBTypeNameSpecifier("NoSuchType")), "deleting a non-existing summary worked") self.assertFalse( category.DeleteTypeFormat( lldb.SBTypeNameSpecifier("NoSuchType")), "deleting a non-existing format worked") self.assertFalse( category.DeleteTypeSynthetic( lldb.SBTypeNameSpecifier("NoSuchType")), "deleting a non-existing synthetic worked") self.assertFalse( category.DeleteTypeFilter( lldb.SBTypeNameSpecifier("")), "deleting a filter for '' worked") self.assertFalse( category.DeleteTypeSummary( lldb.SBTypeNameSpecifier("")), "deleting a summary for '' worked") self.assertFalse( category.DeleteTypeFormat( lldb.SBTypeNameSpecifier("")), "deleting a format for '' worked") self.assertFalse( category.DeleteTypeSynthetic( lldb.SBTypeNameSpecifier("")), "deleting a synthetic for '' worked") try: self.assertFalse( category.AddTypeSummary( lldb.SBTypeNameSpecifier("NoneSuchType"), None), "adding a summary valued None worked") except: pass else: self.assertFalse(True, "adding a summary valued None worked") try: self.assertFalse( category.AddTypeFilter( lldb.SBTypeNameSpecifier("NoneSuchType"), None), "adding a filter valued None worked") except: pass else: self.assertFalse(True, "adding a filter valued None worked") try: self.assertFalse( category.AddTypeSynthetic( lldb.SBTypeNameSpecifier("NoneSuchType"), None), "adding a synthetic valued None worked") except: pass else: self.assertFalse(True, "adding a synthetic valued None worked") try: self.assertFalse( category.AddTypeFormat( lldb.SBTypeNameSpecifier("NoneSuchType"), None), "adding a format valued None worked") except: pass else: self.assertFalse(True, "adding a format valued None worked") self.assertFalse( category.AddTypeSummary( lldb.SBTypeNameSpecifier("EmptySuchType"), lldb.SBTypeSummary()), "adding a summary without value worked") self.assertFalse( category.AddTypeFilter( lldb.SBTypeNameSpecifier("EmptySuchType"), lldb.SBTypeFilter()), "adding a filter without value worked") self.assertFalse( category.AddTypeSynthetic( lldb.SBTypeNameSpecifier("EmptySuchType"), lldb.SBTypeSynthetic()), "adding a synthetic without value worked") self.assertFalse( category.AddTypeFormat( lldb.SBTypeNameSpecifier("EmptySuchType"), lldb.SBTypeFormat()), "adding a format without value worked") self.assertFalse( category.AddTypeSummary( lldb.SBTypeNameSpecifier(""), lldb.SBTypeSummary.CreateWithSummaryString("")), "adding a summary for an invalid type worked") self.assertFalse( category.AddTypeFilter( lldb.SBTypeNameSpecifier(""), lldb.SBTypeFilter(0)), "adding a filter for an invalid type worked") self.assertFalse( category.AddTypeSynthetic( lldb.SBTypeNameSpecifier(""), lldb.SBTypeSynthetic.CreateWithClassName("")), "adding a synthetic for an invalid type worked") self.assertFalse( category.AddTypeFormat( lldb.SBTypeNameSpecifier(""), lldb.SBTypeFormat( lldb.eFormatHex)), "adding a format for an invalid type worked") new_category = self.dbg.CreateCategory("newbar") new_category.AddTypeSummary( lldb.SBTypeNameSpecifier("JustAStruct"), lldb.SBTypeSummary.CreateWithScriptCode("return 'hello scripted world';")) self.expect("frame variable foo", matching=False, substrs=['hello scripted world']) new_category.SetEnabled(True) self.expect("frame variable foo", matching=True, substrs=['hello scripted world']) self.expect("frame variable foo_ptr", matching=True, substrs=['hello scripted world']) new_category.AddTypeSummary( lldb.SBTypeNameSpecifier("JustAStruct"), lldb.SBTypeSummary.CreateWithScriptCode( "return 'hello scripted world';", lldb.eTypeOptionSkipPointers)) self.expect("frame variable foo", matching=True, substrs=['hello scripted world']) frame = self.dbg.GetSelectedTarget().GetProcess( ).GetSelectedThread().GetSelectedFrame() foo_ptr = frame.FindVariable("foo_ptr") summary = foo_ptr.GetTypeSummary() self.assertFalse( summary.IsValid(), "summary found for foo* when none was planned") self.expect("frame variable foo_ptr", matching=False, substrs=['hello scripted world']) new_category.AddTypeSummary( lldb.SBTypeNameSpecifier("JustAStruct"), lldb.SBTypeSummary.CreateWithSummaryString( "hello static world", lldb.eTypeOptionNone)) summary = foo_ptr.GetTypeSummary() self.assertTrue( summary.IsValid(), "no summary found for foo* when one was in place") self.assertEqual( summary.GetData(), "hello static world", "wrong summary found for foo*") self.expect("frame variable e1", substrs=["I am an empty Empty1 {}"]) self.expect("frame variable e2", substrs=["I am an empty Empty2"]) self.expect( "frame variable e2", substrs=["I am an empty Empty2 {}"], matching=False) self.assertTrue( self.dbg.GetCategory( lldb.eLanguageTypeObjC) is not None, "ObjC category is None")
def TypePrintFormating(debugger): # # Set the default print formatting for EFI types in lldb. # seems lldb defaults to decimal. # category = debugger.GetDefaultCategory() FormatBool = lldb.SBTypeFormat(lldb.eFormatBoolean) category.AddTypeFormat(lldb.SBTypeNameSpecifier("BOOLEAN"), FormatBool) FormatHex = lldb.SBTypeFormat(lldb.eFormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT64"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT64"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT32"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT32"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINTN"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INTN"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_PHYSICAL_ADDRESS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("PHYSICAL_ADDRESS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_STATUS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_TPL"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_LBA"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_BOOT_MODE"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_FV_FILETYPE"), FormatHex) # # Smart type printing for EFI # debugger.HandleCommand("type summary add EFI_GUID --python-function lldbefi.EFI_GUID_TypeSummary") debugger.HandleCommand("type summary add EFI_STATUS --python-function lldbefi.EFI_STATUS_TypeSummary") debugger.HandleCommand("type summary add EFI_TPL --python-function lldbefi.EFI_TPL_TypeSummary") debugger.HandleCommand("type summary add EFI_DEVICE_PATH_PROTOCOL --python-function lldbefi.EFI_DEVICE_PATH_PROTOCOL_TypeSummary") debugger.HandleCommand("type summary add CHAR16 --python-function lldbefi.CHAR16_TypeSummary") debugger.HandleCommand('type summary add --regex "CHAR16 \[[0-9]+\]" --python-function lldbefi.CHAR16_TypeSummary') debugger.HandleCommand("type summary add CHAR8 --python-function lldbefi.CHAR8_TypeSummary") debugger.HandleCommand('type summary add --regex "CHAR8 \[[0-9]+\]" --python-function lldbefi.CHAR8_TypeSummary') debugger.HandleCommand( 'setting set frame-format "frame #${frame.index}: ${frame.pc}' '{ ${module.file.basename}{:${function.name}()${function.pc-offset}}}' '{ at ${line.file.fullpath}:${line.number}}\n"' )
def TypePrintFormating(debugger): # # Set the default print formating for EFI types in lldb. # seems lldb defaults to decimal. # category = debugger.GetDefaultCategory() FormatBool = lldb.SBTypeFormat(lldb.eFormatBoolean) category.AddTypeFormat(lldb.SBTypeNameSpecifier("BOOLEAN"), FormatBool) FormatHex = lldb.SBTypeFormat(lldb.eFormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT64"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT64"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT32"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT32"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINTN"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INTN"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_PHYSICAL_ADDRESS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("PHYSICAL_ADDRESS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_STATUS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_TPL"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_LBA"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_BOOT_MODE"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_FV_FILETYPE"), FormatHex) # # Smart type printing for EFI # debugger.HandleCommand( "type summary add EFI_GUID --python-function lldbefi.EFI_GUID_TypeSummary" ) debugger.HandleCommand( "type summary add EFI_STATUS --python-function lldbefi.EFI_STATUS_TypeSummary" ) debugger.HandleCommand( "type summary add EFI_TPL --python-function lldbefi.EFI_TPL_TypeSummary" ) debugger.HandleCommand( "type summary add EFI_DEVICE_PATH_PROTOCOL --python-function lldbefi.EFI_DEVICE_PATH_PROTOCOL_TypeSummary" ) debugger.HandleCommand( "type summary add CHAR16 --python-function lldbefi.CHAR16_TypeSummary") debugger.HandleCommand( 'type summary add --regex "CHAR16 \[[0-9]+\]" --python-function lldbefi.CHAR16_TypeSummary' ) debugger.HandleCommand( "type summary add CHAR8 --python-function lldbefi.CHAR8_TypeSummary") debugger.HandleCommand( 'type summary add --regex "CHAR8 \[[0-9]+\]" --python-function lldbefi.CHAR8_TypeSummary' )
def __call__(self, debugger, command, exe_ctx, result): self.debugger = debugger category = debugger.GetDefaultCategory() FormatBool = lldb.SBTypeFormat(lldb.eFormatBoolean) category.AddTypeFormat(lldb.SBTypeNameSpecifier("BOOLEAN"), FormatBool) FormatHex = lldb.SBTypeFormat(lldb.eFormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT64"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT64"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT32"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT32"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINTN"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INTN"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_PHYSICAL_ADDRESS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("PHYSICAL_ADDRESS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_STATUS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_TPL"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_LBA"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_BOOT_MODE"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_FV_FILETYPE"), FormatHex) args = shlex.split(command) try: opts, args = getopt.getopt(args, "o", ["offset-by-headers"]) except (getopt.GetoptError) as err: self.usage () return for opt, arg in opts: if opt == "-o": self.offset_by_headers = True self.typetarget = None self.activetarget = None # FIXME: Use ReadCStringFromMemory. # FIXME: Support executing code. if len(args) >= 1 and args[0] != '': gdb.execute ("symbol-file") gdb.execute ("symbol-file %s" % args[0]) else: for i in range(0, self.debugger.GetNumTargets()): target = self.debugger.GetTargetAtIndex(i) target_name = str(target) print('Target {} is "{}"'.format(i, target_name)) if target_name.find('GdbSyms') >= 0: self.typetarget = target elif target_name.find('No executable module.') >= 0: self.activetarget = target if not self.typetarget: print('Cannot find GdbSyms target!') return if not self.activetarget: print('Cannot find target with full memory access!') return # Force into full memory target. self.debugger.SetSelectedTarget(self.activetarget) est = self.search_est () if est == self.EINVAL: print ("No EFI_SYSTEM_TABLE...") return print ("EFI_SYSTEM_TABLE @ 0x%x" % est.GetValueAsUnsigned()) self.parse_est (est)
def lldb_type_formaters(debugger, mod_name): '''Teach lldb about EFI types''' category = debugger.GetDefaultCategory() FormatBool = lldb.SBTypeFormat(lldb.eFormatBoolean) category.AddTypeFormat(lldb.SBTypeNameSpecifier("BOOLEAN"), FormatBool) FormatHex = lldb.SBTypeFormat(lldb.eFormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT64"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT64"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT32"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT32"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINTN"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("INTN"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR8"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR16"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier( "EFI_PHYSICAL_ADDRESS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier( "PHYSICAL_ADDRESS"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_LBA"), FormatHex) category.AddTypeFormat( lldb.SBTypeNameSpecifier("EFI_BOOT_MODE"), FormatHex) category.AddTypeFormat(lldb.SBTypeNameSpecifier( "EFI_FV_FILETYPE"), FormatHex) # # Smart type printing for EFI # debugger.HandleCommand( f'type summary add GUID - -python-function ' f'{mod_name}.EFI_GUID_TypeSummary') debugger.HandleCommand( f'type summary add EFI_GUID --python-function ' f'{mod_name}.EFI_GUID_TypeSummary') debugger.HandleCommand( f'type summary add EFI_STATUS --python-function ' f'{mod_name}.EFI_STATUS_TypeSummary') debugger.HandleCommand( f'type summary add EFI_TPL - -python-function ' f'{mod_name}.EFI_TPL_TypeSummary') debugger.HandleCommand( f'type summary add EFI_BOOT_MODE --python-function ' f'{mod_name}.EFI_BOOT_MODE_TypeSummary') debugger.HandleCommand( f'type summary add CHAR16 --python-function ' f'{mod_name}.CHAR16_TypeSummary') # W605 this is the correct escape sequence for the lldb command debugger.HandleCommand( f'type summary add --regex "CHAR16 \[[0-9]+\]" ' # noqa: W605 f'--python-function {mod_name}.CHAR16_TypeSummary') debugger.HandleCommand( f'type summary add CHAR8 --python-function ' f'{mod_name}.CHAR8_TypeSummary') # W605 this is the correct escape sequence for the lldb command debugger.HandleCommand( f'type summary add --regex "CHAR8 \[[0-9]+\]" ' # noqa: W605 f'--python-function {mod_name}.CHAR8_TypeSummary')
import lldb def Struct_SummaryFormatter(valobj, internal_dict): return 'A data formatter at work' category = lldb.debugger.CreateCategory("TSLSFormatters") category.SetEnabled(True) summary = lldb.SBTypeSummary.CreateWithFunctionName( "tslsformatters.Struct_SummaryFormatter", lldb.eTypeOptionCascade) spec = lldb.SBTypeNameSpecifier("Struct", False) category.AddTypeSummary(spec, summary)