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/DataFormatters/DumpValueObjectOptions.h" 12 #include "lldb/Expression/ExpressionVariable.h" 13 #include "lldb/Expression/UserExpression.h" 14 #include "lldb/Interpreter/CommandInterpreter.h" 15 #include "lldb/Interpreter/CommandObject.h" 16 #include "lldb/Interpreter/CommandReturnObject.h" 17 #include "lldb/Interpreter/OptionGroupFormat.h" 18 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h" 19 #include "lldb/Target/StackFrame.h" 20 #include "lldb/Utility/ConstString.h" 21 #include "lldb/ValueObject/ValueObject.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 27 #include <regex> 28 29 using namespace llvm; 30 using namespace lldb; 31 using namespace lldb_private; 32 33 CommandObjectDWIMPrint::CommandObjectDWIMPrint(CommandInterpreter &interpreter) 34 : CommandObjectRaw(interpreter, "dwim-print", 35 "Print a variable or expression.", 36 "dwim-print [<variable-name> | <expression>]", 37 eCommandProcessMustBePaused | eCommandTryTargetAPILock) { 38 39 AddSimpleArgumentList(eArgTypeVarName); 40 41 m_option_group.Append(&m_format_options, 42 OptionGroupFormat::OPTION_GROUP_FORMAT | 43 OptionGroupFormat::OPTION_GROUP_GDB_FMT, 44 LLDB_OPT_SET_1); 45 StringRef exclude_expr_options[] = {"debug", "top-level"}; 46 m_option_group.Append(&m_expr_options, exclude_expr_options); 47 m_option_group.Append(&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 48 m_option_group.Finalize(); 49 } 50 51 Options *CommandObjectDWIMPrint::GetOptions() { return &m_option_group; } 52 53 void CommandObjectDWIMPrint::DoExecute(StringRef command, 54 CommandReturnObject &result) { 55 m_option_group.NotifyOptionParsingStarting(&m_exe_ctx); 56 OptionsWithRaw args{command}; 57 StringRef expr = args.GetRawPart(); 58 59 if (expr.empty()) { 60 result.AppendErrorWithFormatv("'{0}' takes a variable or expression", 61 m_cmd_name); 62 return; 63 } 64 65 if (args.HasArgs()) { 66 if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group, 67 m_exe_ctx)) 68 return; 69 } 70 71 // If the user has not specified, default to disabling persistent results. 72 if (m_expr_options.suppress_persistent_result == eLazyBoolCalculate) 73 m_expr_options.suppress_persistent_result = eLazyBoolYes; 74 bool suppress_result = m_expr_options.ShouldSuppressResult(m_varobj_options); 75 76 auto verbosity = GetDebugger().GetDWIMPrintVerbosity(); 77 78 Target *target_ptr = m_exe_ctx.GetTargetPtr(); 79 // Fallback to the dummy target, which can allow for expression evaluation. 80 Target &target = target_ptr ? *target_ptr : GetDummyTarget(); 81 82 EvaluateExpressionOptions eval_options = 83 m_expr_options.GetEvaluateExpressionOptions(target, m_varobj_options); 84 // This command manually removes the result variable, make sure expression 85 // evaluation doesn't do it first. 86 eval_options.SetSuppressPersistentResult(false); 87 88 DumpValueObjectOptions dump_options = m_varobj_options.GetAsDumpOptions( 89 m_expr_options.m_verbosity, m_format_options.GetFormat()); 90 dump_options.SetHideRootName(suppress_result); 91 92 bool is_po = m_varobj_options.use_objc; 93 94 StackFrame *frame = m_exe_ctx.GetFramePtr(); 95 96 // Either the language was explicitly specified, or we check the frame. 97 lldb::LanguageType language = m_expr_options.language; 98 if (language == lldb::eLanguageTypeUnknown && frame) 99 language = frame->GuessLanguage().AsLanguageType(); 100 101 // Add a hint if object description was requested, but no description 102 // function was implemented. 103 auto maybe_add_hint = [&](llvm::StringRef output) { 104 // Identify the default output of object description for Swift and 105 // Objective-C 106 // "<Name: 0x...>. The regex is: 107 // - Start with "<". 108 // - Followed by 1 or more non-whitespace characters. 109 // - Followed by ": 0x". 110 // - Followed by 5 or more hex digits. 111 // - Followed by ">". 112 // - End with zero or more whitespace characters. 113 const std::regex swift_class_regex("^<\\S+: 0x[[:xdigit:]]{5,}>\\s*$"); 114 115 if (GetDebugger().GetShowDontUsePoHint() && target_ptr && 116 (language == lldb::eLanguageTypeSwift || 117 language == lldb::eLanguageTypeObjC) && 118 std::regex_match(output.data(), swift_class_regex)) { 119 120 static bool note_shown = false; 121 if (note_shown) 122 return; 123 124 result.AppendNote( 125 "object description requested, but type doesn't implement " 126 "a custom object description. Consider using \"p\" instead of " 127 "\"po\" (this note will only be shown once per debug session).\n"); 128 note_shown = true; 129 } 130 }; 131 132 // Dump `valobj` according to whether `po` was requested or not. 133 auto dump_val_object = [&](ValueObject &valobj) { 134 if (is_po) { 135 StreamString temp_result_stream; 136 if (llvm::Error error = valobj.Dump(temp_result_stream, dump_options)) { 137 result.AppendError(toString(std::move(error))); 138 return; 139 } 140 llvm::StringRef output = temp_result_stream.GetString(); 141 maybe_add_hint(output); 142 result.GetOutputStream() << output; 143 } else { 144 llvm::Error error = 145 valobj.Dump(result.GetOutputStream(), dump_options); 146 if (error) { 147 result.AppendError(toString(std::move(error))); 148 return; 149 } 150 } 151 result.SetStatus(eReturnStatusSuccessFinishResult); 152 }; 153 154 // First, try `expr` as a _limited_ frame variable expression path: only the 155 // dot operator (`.`) is permitted for this case. 156 // 157 // This is limited to support only unambiguous expression paths. Of note, 158 // expression paths are not attempted if the expression contain either the 159 // arrow operator (`->`) or the subscript operator (`[]`). This is because 160 // both operators can be overloaded in C++, and could result in ambiguity in 161 // how the expression is handled. Additionally, `*` and `&` are not supported. 162 const bool try_variable_path = 163 expr.find_first_of("*&->[]") == StringRef::npos; 164 if (frame && try_variable_path) { 165 VariableSP var_sp; 166 Status status; 167 auto valobj_sp = frame->GetValueForVariableExpressionPath( 168 expr, eval_options.GetUseDynamic(), 169 StackFrame::eExpressionPathOptionsAllowDirectIVarAccess, var_sp, 170 status); 171 if (valobj_sp && status.Success() && valobj_sp->GetError().Success()) { 172 if (!suppress_result) { 173 if (auto persisted_valobj = valobj_sp->Persist()) 174 valobj_sp = persisted_valobj; 175 } 176 177 if (verbosity == eDWIMPrintVerbosityFull) { 178 StringRef flags; 179 if (args.HasArgs()) 180 flags = args.GetArgString(); 181 result.AppendNoteWithFormatv("ran `frame variable {0}{1}`", flags, 182 expr); 183 } 184 185 dump_val_object(*valobj_sp); 186 return; 187 } 188 } 189 190 // Second, try `expr` as a persistent variable. 191 if (expr.starts_with("$")) 192 if (auto *state = target.GetPersistentExpressionStateForLanguage(language)) 193 if (auto var_sp = state->GetVariable(expr)) 194 if (auto valobj_sp = var_sp->GetValueObject()) { 195 dump_val_object(*valobj_sp); 196 return; 197 } 198 199 // Third, and lastly, try `expr` as a source expression to evaluate. 200 { 201 auto *exe_scope = m_exe_ctx.GetBestExecutionContextScope(); 202 ValueObjectSP valobj_sp; 203 std::string fixed_expression; 204 205 ExpressionResults expr_result = target.EvaluateExpression( 206 expr, exe_scope, valobj_sp, eval_options, &fixed_expression); 207 208 // Record the position of the expression in the command. 209 std::optional<uint16_t> indent; 210 if (fixed_expression.empty()) { 211 size_t pos = m_original_command.rfind(expr); 212 if (pos != llvm::StringRef::npos) 213 indent = pos; 214 } 215 // Previously the indent was set up for diagnosing command line 216 // parsing errors. Now point it to the expression. 217 result.SetDiagnosticIndent(indent); 218 219 // Only mention Fix-Its if the expression evaluator applied them. 220 // Compiler errors refer to the final expression after applying Fix-It(s). 221 if (!fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) { 222 Stream &error_stream = result.GetErrorStream(); 223 error_stream << " Evaluated this expression after applying Fix-It(s):\n"; 224 error_stream << " " << fixed_expression << "\n"; 225 } 226 227 // If the expression failed, return an error. 228 if (expr_result != eExpressionCompleted) { 229 if (valobj_sp) 230 result.SetError(valobj_sp->GetError().Clone()); 231 else 232 result.AppendErrorWithFormatv( 233 "unknown error evaluating expression `{0}`", expr); 234 return; 235 } 236 237 if (verbosity != eDWIMPrintVerbosityNone) { 238 StringRef flags; 239 if (args.HasArgs()) 240 flags = args.GetArgStringWithDelimiter(); 241 result.AppendNoteWithFormatv("ran `expression {0}{1}`", flags, expr); 242 } 243 244 if (valobj_sp->GetError().GetError() != UserExpression::kNoResult) 245 dump_val_object(*valobj_sp); 246 else 247 result.SetStatus(eReturnStatusSuccessFinishNoResult); 248 249 if (suppress_result) 250 if (auto result_var_sp = 251 target.GetPersistentVariable(valobj_sp->GetName())) { 252 auto language = valobj_sp->GetPreferredDisplayLanguage(); 253 if (auto *persistent_state = 254 target.GetPersistentExpressionStateForLanguage(language)) 255 persistent_state->RemovePersistentVariable(result_var_sp); 256 } 257 } 258 } 259