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
27#include <regex>
28
29using namespace llvm;
30using namespace lldb;
31using namespace lldb_private;
32
33CommandObjectDWIMPrint::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
51Options *CommandObjectDWIMPrint::GetOptions() { return &m_option_group; }
52
53void 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
92 bool is_po = m_varobj_options.use_objc;
93
94 StackFrame *frame = m_exe_ctx.GetFramePtr();
95
96 // Either Swift was explicitly specified, or the frame is Swift.
97 lldb::LanguageType language = m_expr_options.language;
98 if (language == lldb::eLanguageTypeUnknown && frame)
99 language = frame->GuessLanguage();
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(s: output.data(), re: swift_class_regex)) {
119
120 static bool note_shown = false;
121 if (note_shown)
122 return;
123
124 result.GetOutputStream()
125 << "note: 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 valobj.Dump(s&: temp_result_stream, options: dump_options);
137 llvm::StringRef output = temp_result_stream.GetString();
138 maybe_add_hint(output);
139 result.GetOutputStream() << output;
140 } else {
141 valobj.Dump(s&: result.GetOutputStream(), options: dump_options);
142 }
143 };
144
145 // First, try `expr` as the name of a frame variable.
146 if (frame) {
147 auto valobj_sp = frame->FindVariable(name: ConstString(expr));
148 if (valobj_sp && valobj_sp->GetError().Success()) {
149 if (!suppress_result) {
150 if (auto persisted_valobj = valobj_sp->Persist())
151 valobj_sp = persisted_valobj;
152 }
153
154 if (verbosity == eDWIMPrintVerbosityFull) {
155 StringRef flags;
156 if (args.HasArgs())
157 flags = args.GetArgString();
158 result.AppendMessageWithFormatv(format: "note: ran `frame variable {0}{1}`",
159 args&: flags, args&: expr);
160 }
161
162 dump_val_object(*valobj_sp);
163 result.SetStatus(eReturnStatusSuccessFinishResult);
164 return;
165 }
166 }
167
168 // Second, try `expr` as a persistent variable.
169 if (expr.starts_with(Prefix: "$"))
170 if (auto *state = target.GetPersistentExpressionStateForLanguage(language))
171 if (auto var_sp = state->GetVariable(name: expr))
172 if (auto valobj_sp = var_sp->GetValueObject()) {
173 dump_val_object(*valobj_sp);
174 result.SetStatus(eReturnStatusSuccessFinishResult);
175 return;
176 }
177
178 // Third, and lastly, try `expr` as a source expression to evaluate.
179 {
180 auto *exe_scope = m_exe_ctx.GetBestExecutionContextScope();
181 ValueObjectSP valobj_sp;
182 std::string fixed_expression;
183
184 ExpressionResults expr_result = target.EvaluateExpression(
185 expression: expr, exe_scope, result_valobj_sp&: valobj_sp, options: eval_options, fixed_expression: &fixed_expression);
186
187 // Only mention Fix-Its if the expression evaluator applied them.
188 // Compiler errors refer to the final expression after applying Fix-It(s).
189 if (!fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) {
190 Stream &error_stream = result.GetErrorStream();
191 error_stream << " Evaluated this expression after applying Fix-It(s):\n";
192 error_stream << " " << fixed_expression << "\n";
193 }
194
195 if (expr_result == eExpressionCompleted) {
196 if (verbosity != eDWIMPrintVerbosityNone) {
197 StringRef flags;
198 if (args.HasArgs())
199 flags = args.GetArgStringWithDelimiter();
200 result.AppendMessageWithFormatv(format: "note: ran `expression {0}{1}`", args&: flags,
201 args&: expr);
202 }
203
204 if (valobj_sp->GetError().GetError() != UserExpression::kNoResult)
205 dump_val_object(*valobj_sp);
206
207 if (suppress_result)
208 if (auto result_var_sp =
209 target.GetPersistentVariable(name: valobj_sp->GetName())) {
210 auto language = valobj_sp->GetPreferredDisplayLanguage();
211 if (auto *persistent_state =
212 target.GetPersistentExpressionStateForLanguage(language))
213 persistent_state->RemovePersistentVariable(variable: result_var_sp);
214 }
215
216 result.SetStatus(eReturnStatusSuccessFinishResult);
217 } else {
218 if (valobj_sp)
219 result.SetError(error: valobj_sp->GetError());
220 else
221 result.AppendErrorWithFormatv(
222 format: "unknown error evaluating expression `{0}`", args&: expr);
223 }
224 }
225}
226

source code of lldb/source/Commands/CommandObjectDWIMPrint.cpp