[lldb][tests] Automatically call compute_mydir (NFC)Eliminate boilerplate of having each test manually assign to `mydir` by calling`compute_mydir` in lldbtest.py.Differential Revision: https://r
[lldb][tests] Automatically call compute_mydir (NFC)Eliminate boilerplate of having each test manually assign to `mydir` by calling`compute_mydir` in lldbtest.py.Differential Revision: https://reviews.llvm.org/D128077
show more ...
[lldb][import-std-module] Prefer the non-module diagnostics when in fallback modeThe `fallback` setting for import-std-module is supposed to allow runningexpression that require an imported C++ mo
[lldb][import-std-module] Prefer the non-module diagnostics when in fallback modeThe `fallback` setting for import-std-module is supposed to allow runningexpression that require an imported C++ module without causing any regressionsfor users (neither in terms of functionality nor performance). This is done byfirst trying to normally parse/evaluate an expression and when an error occurredduring this first attempt, we retry with the loaded 'std' module.When we run into a system with a 'std' module that for some reason doesn't buildor otherwise causes parse errors, then this currently means that the secondparse attempt will overwrite the error diagnostics of the first parse attempt.Given that the module build errors are outside of the scope of what the user caninfluence, it makes more sense to show the errors from the first parse attemptthat are only concerned with the actual user input.Reviewed By: aprantlDifferential Revision: https://reviews.llvm.org/D110696
[lldb] Allow LLDB to automatically retry a failed expression with an imported std C++ moduleBy now LLDB can import the 'std' C++ module to improve expression evaluation,but there are still a few p
[lldb] Allow LLDB to automatically retry a failed expression with an imported std C++ moduleBy now LLDB can import the 'std' C++ module to improve expression evaluation,but there are still a few problems to solve before we can do this by default.One is that importing the C++ module is slightly slower than normal expressionevaluation (mostly because the disk access and loading the initial lookup datais quite slow in comparison to the barebone Clang setup the rest of the LLDBexpression evaluator is usually doing). Another problem is that some complicatedtypes in the standard library aren't fully supported yet by the ASTImporter, sowe end up types that fail to import (which usually appears to the user as if thetype is empty or there is just no result variable).To still allow people to adopt this mode in their daily debugging, this patchadds a setting that allows LLDB to automatically retry failed expression with aloaded C++ module. All success expressions will behave exactly as they would dobefore this patch. Failed expressions get a another parse attempt if we find ausable C++ module in the current execution context. This way we shouldn't haveany performance/parsing regressions in normal debugging workflows, while thedebugging workflows involving STL containers benefit from the C++ module typeinfo.This setting is off by default for now with the intention to enable it bydefault on macOS soon-ish.The implementation is mostly just extracting the existing parse logic into itsown function and then calling the parse function again if the first evaluationfailed and we have a C++ module to retry the parsing with.Reviewed By: shafik, JDevlieghere, aprantlDifferential Revision: https://reviews.llvm.org/D92784