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(arg_type: eArgTypeVarName); |
40 | |
41 | m_option_group.Append(group: &m_format_options, |
42 | src_mask: 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(group: &m_expr_options, exclude_long_options: exclude_expr_options); |
47 | m_option_group.Append(group: &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(execution_context: &m_exe_ctx); |
56 | OptionsWithRaw args{command}; |
57 | StringRef expr = args.GetRawPart(); |
58 | |
59 | if (expr.empty()) { |
60 | result.AppendErrorWithFormatv(format: "'{0}' takes a variable or expression" , |
61 | args&: m_cmd_name); |
62 | return; |
63 | } |
64 | |
65 | if (args.HasArgs()) { |
66 | if (!ParseOptionsAndNotify(args&: args.GetArgs(), result, group_options&: m_option_group, |
67 | exe_ctx&: 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(display_opts: 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, display_opts: 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 | lang_descr_verbosity: m_expr_options.m_verbosity, format: m_format_options.GetFormat()); |
90 | dump_options.SetHideRootName(suppress_result) |
91 | .SetExpandPointerTypeFlags(lldb::eTypeIsObjC); |
92 | |
93 | bool is_po = m_varobj_options.use_objc; |
94 | |
95 | StackFrame *frame = m_exe_ctx.GetFramePtr(); |
96 | |
97 | // Either the language was explicitly specified, or we check the frame. |
98 | lldb::LanguageType language = m_expr_options.language; |
99 | if (language == lldb::eLanguageTypeUnknown && frame) |
100 | language = frame->GuessLanguage().AsLanguageType(); |
101 | |
102 | // Add a hint if object description was requested, but no description |
103 | // function was implemented. |
104 | auto maybe_add_hint = [&](llvm::StringRef output) { |
105 | static bool note_shown = false; |
106 | if (note_shown) |
107 | return; |
108 | |
109 | // Identify the default output of object description for Swift and |
110 | // Objective-C |
111 | // "<Name: 0x...>. The regex is: |
112 | // - Start with "<". |
113 | // - Followed by 1 or more non-whitespace characters. |
114 | // - Followed by ": 0x". |
115 | // - Followed by 5 or more hex digits. |
116 | // - Followed by ">". |
117 | // - End with zero or more whitespace characters. |
118 | static const std::regex swift_class_regex( |
119 | "^<\\S+: 0x[[:xdigit:]]{5,}>\\s*$" ); |
120 | |
121 | if (GetDebugger().GetShowDontUsePoHint() && target_ptr && |
122 | (language == lldb::eLanguageTypeSwift || |
123 | language == lldb::eLanguageTypeObjC) && |
124 | std::regex_match(s: output.data(), re: swift_class_regex)) { |
125 | |
126 | result.AppendNote( |
127 | in_string: "object description requested, but type doesn't implement " |
128 | "a custom object description. Consider using \"p\" instead of " |
129 | "\"po\" (this note will only be shown once per debug session).\n" ); |
130 | note_shown = true; |
131 | } |
132 | }; |
133 | |
134 | // Dump `valobj` according to whether `po` was requested or not. |
135 | auto dump_val_object = [&](ValueObject &valobj) { |
136 | if (is_po) { |
137 | StreamString temp_result_stream; |
138 | if (llvm::Error error = valobj.Dump(s&: temp_result_stream, options: dump_options)) { |
139 | result.AppendError(in_string: toString(E: std::move(error))); |
140 | return; |
141 | } |
142 | llvm::StringRef output = temp_result_stream.GetString(); |
143 | maybe_add_hint(output); |
144 | result.GetOutputStream() << output; |
145 | } else { |
146 | llvm::Error error = |
147 | valobj.Dump(s&: result.GetOutputStream(), options: dump_options); |
148 | if (error) { |
149 | result.AppendError(in_string: toString(E: std::move(error))); |
150 | return; |
151 | } |
152 | } |
153 | result.SetStatus(eReturnStatusSuccessFinishResult); |
154 | }; |
155 | |
156 | // First, try `expr` as a _limited_ frame variable expression path: only the |
157 | // dot operator (`.`) is permitted for this case. |
158 | // |
159 | // This is limited to support only unambiguous expression paths. Of note, |
160 | // expression paths are not attempted if the expression contain either the |
161 | // arrow operator (`->`) or the subscript operator (`[]`). This is because |
162 | // both operators can be overloaded in C++, and could result in ambiguity in |
163 | // how the expression is handled. Additionally, `*` and `&` are not supported. |
164 | const bool try_variable_path = |
165 | expr.find_first_of(Chars: "*&->[]" ) == StringRef::npos; |
166 | if (frame && try_variable_path) { |
167 | VariableSP var_sp; |
168 | Status status; |
169 | auto valobj_sp = frame->GetValueForVariableExpressionPath( |
170 | var_expr: expr, use_dynamic: eval_options.GetUseDynamic(), |
171 | options: StackFrame::eExpressionPathOptionsAllowDirectIVarAccess, var_sp, |
172 | error&: status); |
173 | if (valobj_sp && status.Success() && valobj_sp->GetError().Success()) { |
174 | if (!suppress_result) { |
175 | if (auto persisted_valobj = valobj_sp->Persist()) |
176 | valobj_sp = persisted_valobj; |
177 | } |
178 | |
179 | if (verbosity == eDWIMPrintVerbosityFull) { |
180 | StringRef flags; |
181 | if (args.HasArgs()) |
182 | flags = args.GetArgString(); |
183 | result.AppendNoteWithFormatv(format: "ran `frame variable {0}{1}`" , args&: flags, |
184 | args&: expr); |
185 | } |
186 | |
187 | dump_val_object(*valobj_sp); |
188 | return; |
189 | } |
190 | } |
191 | |
192 | // Second, try `expr` as a persistent variable. |
193 | if (expr.starts_with(Prefix: "$" )) |
194 | if (auto *state = target.GetPersistentExpressionStateForLanguage(language)) |
195 | if (auto var_sp = state->GetVariable(name: expr)) |
196 | if (auto valobj_sp = var_sp->GetValueObject()) { |
197 | dump_val_object(*valobj_sp); |
198 | return; |
199 | } |
200 | |
201 | // Third, and lastly, try `expr` as a source expression to evaluate. |
202 | { |
203 | auto *exe_scope = m_exe_ctx.GetBestExecutionContextScope(); |
204 | ValueObjectSP valobj_sp; |
205 | std::string fixed_expression; |
206 | |
207 | ExpressionResults expr_result = target.EvaluateExpression( |
208 | expression: expr, exe_scope, result_valobj_sp&: valobj_sp, options: eval_options, fixed_expression: &fixed_expression); |
209 | |
210 | if (valobj_sp) |
211 | result.GetValueObjectList().Append(val_obj_sp: valobj_sp); |
212 | |
213 | // Record the position of the expression in the command. |
214 | std::optional<uint16_t> indent; |
215 | if (fixed_expression.empty()) { |
216 | size_t pos = m_original_command.rfind(svt: expr); |
217 | if (pos != llvm::StringRef::npos) |
218 | indent = pos; |
219 | } |
220 | // Previously the indent was set up for diagnosing command line |
221 | // parsing errors. Now point it to the expression. |
222 | result.SetDiagnosticIndent(indent); |
223 | |
224 | // Only mention Fix-Its if the expression evaluator applied them. |
225 | // Compiler errors refer to the final expression after applying Fix-It(s). |
226 | if (!fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) { |
227 | Stream &error_stream = result.GetErrorStream(); |
228 | error_stream << " Evaluated this expression after applying Fix-It(s):\n" ; |
229 | error_stream << " " << fixed_expression << "\n" ; |
230 | } |
231 | |
232 | // If the expression failed, return an error. |
233 | if (expr_result != eExpressionCompleted) { |
234 | if (valobj_sp) |
235 | result.SetError(valobj_sp->GetError().Clone()); |
236 | else |
237 | result.AppendErrorWithFormatv( |
238 | format: "unknown error evaluating expression `{0}`" , args&: expr); |
239 | return; |
240 | } |
241 | |
242 | if (verbosity != eDWIMPrintVerbosityNone) { |
243 | StringRef flags; |
244 | if (args.HasArgs()) |
245 | flags = args.GetArgStringWithDelimiter(); |
246 | result.AppendNoteWithFormatv(format: "ran `expression {0}{1}`" , args&: flags, args&: expr); |
247 | } |
248 | |
249 | if (valobj_sp->GetError().GetError() != UserExpression::kNoResult) |
250 | dump_val_object(*valobj_sp); |
251 | else |
252 | result.SetStatus(eReturnStatusSuccessFinishNoResult); |
253 | |
254 | if (suppress_result) |
255 | if (auto result_var_sp = |
256 | target.GetPersistentVariable(name: valobj_sp->GetName())) { |
257 | auto language = valobj_sp->GetPreferredDisplayLanguage(); |
258 | if (auto *persistent_state = |
259 | target.GetPersistentExpressionStateForLanguage(language)) |
260 | persistent_state->RemovePersistentVariable(variable: result_var_sp); |
261 | } |
262 | } |
263 | } |
264 | |