1//===-- CommandObjectDWIMPrint.cpp ------------------------------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9#include "CommandObjectDWIMPrint.h" 10 11#include "lldb/Core/ValueObject.h" 12#include "lldb/DataFormatters/DumpValueObjectOptions.h" 13#include "lldb/Expression/ExpressionVariable.h" 14#include "lldb/Expression/UserExpression.h" 15#include "lldb/Interpreter/CommandInterpreter.h" 16#include "lldb/Interpreter/CommandObject.h" 17#include "lldb/Interpreter/CommandReturnObject.h" 18#include "lldb/Interpreter/OptionGroupFormat.h" 19#include "lldb/Interpreter/OptionGroupValueObjectDisplay.h" 20#include "lldb/Target/StackFrame.h" 21#include "lldb/Utility/ConstString.h" 22#include "lldb/lldb-defines.h" 23#include "lldb/lldb-enumerations.h" 24#include "lldb/lldb-forward.h" 25#include "llvm/ADT/StringRef.h" 26#include "llvm/Support/FormatVariadic.h" 27 28#include <regex> 29 30using namespace llvm; 31using namespace lldb; 32using namespace lldb_private; 33 34CommandObjectDWIMPrint::CommandObjectDWIMPrint(CommandInterpreter &interpreter) 35 : CommandObjectRaw(interpreter, "dwim-print", 36 "Print a variable or expression.", 37 "dwim-print [<variable-name> | <expression>]", 38 eCommandProcessMustBePaused | eCommandTryTargetAPILock) { 39 40 CommandArgumentData var_name_arg(eArgTypeVarName, eArgRepeatPlain); 41 m_arguments.push_back({var_name_arg}); 42 43 m_option_group.Append(&m_format_options, 44 OptionGroupFormat::OPTION_GROUP_FORMAT | 45 OptionGroupFormat::OPTION_GROUP_GDB_FMT, 46 LLDB_OPT_SET_1); 47 StringRef exclude_expr_options[] = {"debug", "top-level"}; 48 m_option_group.Append(&m_expr_options, exclude_expr_options); 49 m_option_group.Append(&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 50 m_option_group.Finalize(); 51} 52 53Options *CommandObjectDWIMPrint::GetOptions() { return &m_option_group; } 54 55void CommandObjectDWIMPrint::HandleArgumentCompletion( 56 CompletionRequest &request, OptionElementVector &opt_element_vector) { 57 lldb_private::CommandCompletions::InvokeCommonCompletionCallbacks( 58 GetCommandInterpreter(), lldb::eVariablePathCompletion, request, nullptr); 59} 60 61void CommandObjectDWIMPrint::DoExecute(StringRef command, 62 CommandReturnObject &result) { 63 m_option_group.NotifyOptionParsingStarting(&m_exe_ctx); 64 OptionsWithRaw args{command}; 65 StringRef expr = args.GetRawPart(); 66 67 if (expr.empty()) { 68 result.AppendErrorWithFormatv("'{0}' takes a variable or expression", 69 m_cmd_name); 70 return; 71 } 72 73 if (args.HasArgs()) { 74 if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group, 75 m_exe_ctx)) 76 return; 77 } 78 79 // If the user has not specified, default to disabling persistent results. 80 if (m_expr_options.suppress_persistent_result == eLazyBoolCalculate) 81 m_expr_options.suppress_persistent_result = eLazyBoolYes; 82 bool suppress_result = m_expr_options.ShouldSuppressResult(m_varobj_options); 83 84 auto verbosity = GetDebugger().GetDWIMPrintVerbosity(); 85 86 Target *target_ptr = m_exe_ctx.GetTargetPtr(); 87 // Fallback to the dummy target, which can allow for expression evaluation. 88 Target &target = target_ptr ? *target_ptr : GetDummyTarget(); 89 90 EvaluateExpressionOptions eval_options = 91 m_expr_options.GetEvaluateExpressionOptions(target, m_varobj_options); 92 // This command manually removes the result variable, make sure expression 93 // evaluation doesn't do it first. 94 eval_options.SetSuppressPersistentResult(false); 95 96 DumpValueObjectOptions dump_options = m_varobj_options.GetAsDumpOptions( 97 m_expr_options.m_verbosity, m_format_options.GetFormat()); 98 dump_options.SetHideRootName(suppress_result); 99 100 bool is_po = m_varobj_options.use_objc; 101 102 StackFrame *frame = m_exe_ctx.GetFramePtr(); 103 104 // Either Swift was explicitly specified, or the frame is Swift. 105 lldb::LanguageType language = m_expr_options.language; 106 if (language == lldb::eLanguageTypeUnknown && frame) 107 language = frame->GuessLanguage(); 108 109 // Add a hint if object description was requested, but no description 110 // function was implemented. 111 auto maybe_add_hint = [&](llvm::StringRef output) { 112 // Identify the default output of object description for Swift and 113 // Objective-C 114 // "<Name: 0x...>. The regex is: 115 // - Start with "<". 116 // - Followed by 1 or more non-whitespace characters. 117 // - Followed by ": 0x". 118 // - Followed by 5 or more hex digits. 119 // - Followed by ">". 120 // - End with zero or more whitespace characters. 121 const std::regex swift_class_regex("^<\\S+: 0x[[:xdigit:]]{5,}>\\s*$"); 122 123 if (GetDebugger().GetShowDontUsePoHint() && target_ptr && 124 (language == lldb::eLanguageTypeSwift || 125 language == lldb::eLanguageTypeObjC) && 126 std::regex_match(output.data(), swift_class_regex)) { 127 128 static bool note_shown = false; 129 if (note_shown) 130 return; 131 132 result.GetOutputStream() 133 << "note: object description requested, but type doesn't implement " 134 "a custom object description. Consider using \"p\" instead of " 135 "\"po\" (this note will only be shown once per debug session).\n"; 136 note_shown = true; 137 } 138 }; 139 140 // First, try `expr` as the name of a frame variable. 141 if (frame) { 142 auto valobj_sp = frame->FindVariable(ConstString(expr)); 143 if (valobj_sp && valobj_sp->GetError().Success()) { 144 if (!suppress_result) { 145 if (auto persisted_valobj = valobj_sp->Persist()) 146 valobj_sp = persisted_valobj; 147 } 148 149 if (verbosity == eDWIMPrintVerbosityFull) { 150 StringRef flags; 151 if (args.HasArgs()) 152 flags = args.GetArgString(); 153 result.AppendMessageWithFormatv("note: ran `frame variable {0}{1}`", 154 flags, expr); 155 } 156 157 if (is_po) { 158 StreamString temp_result_stream; 159 valobj_sp->Dump(temp_result_stream, dump_options); 160 llvm::StringRef output = temp_result_stream.GetString(); 161 maybe_add_hint(output); 162 result.GetOutputStream() << output; 163 } else { 164 valobj_sp->Dump(result.GetOutputStream(), dump_options); 165 } 166 result.SetStatus(eReturnStatusSuccessFinishResult); 167 return; 168 } 169 } 170 171 // Second, also lastly, try `expr` as a source expression to evaluate. 172 { 173 auto *exe_scope = m_exe_ctx.GetBestExecutionContextScope(); 174 ValueObjectSP valobj_sp; 175 std::string fixed_expression; 176 177 ExpressionResults expr_result = target.EvaluateExpression( 178 expr, exe_scope, valobj_sp, eval_options, &fixed_expression); 179 180 // Only mention Fix-Its if the expression evaluator applied them. 181 // Compiler errors refer to the final expression after applying Fix-It(s). 182 if (!fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) { 183 Stream &error_stream = result.GetErrorStream(); 184 error_stream << " Evaluated this expression after applying Fix-It(s):\n"; 185 error_stream << " " << fixed_expression << "\n"; 186 } 187 188 if (expr_result == eExpressionCompleted) { 189 if (verbosity != eDWIMPrintVerbosityNone) { 190 StringRef flags; 191 if (args.HasArgs()) 192 flags = args.GetArgStringWithDelimiter(); 193 result.AppendMessageWithFormatv("note: ran `expression {0}{1}`", flags, 194 expr); 195 } 196 197 if (valobj_sp->GetError().GetError() != UserExpression::kNoResult) { 198 if (is_po) { 199 StreamString temp_result_stream; 200 valobj_sp->Dump(temp_result_stream, dump_options); 201 llvm::StringRef output = temp_result_stream.GetString(); 202 maybe_add_hint(output); 203 result.GetOutputStream() << output; 204 } else { 205 valobj_sp->Dump(result.GetOutputStream(), dump_options); 206 } 207 } 208 209 if (suppress_result) 210 if (auto result_var_sp = 211 target.GetPersistentVariable(valobj_sp->GetName())) { 212 auto language = valobj_sp->GetPreferredDisplayLanguage(); 213 if (auto *persistent_state = 214 target.GetPersistentExpressionStateForLanguage(language)) 215 persistent_state->RemovePersistentVariable(result_var_sp); 216 } 217 218 result.SetStatus(eReturnStatusSuccessFinishResult); 219 } else { 220 if (valobj_sp) 221 result.SetError(valobj_sp->GetError()); 222 else 223 result.AppendErrorWithFormatv( 224 "unknown error evaluating expression `{0}`", expr); 225 } 226 } 227} 228