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 
30 using namespace llvm;
31 using namespace lldb;
32 using namespace lldb_private;
33 
CommandObjectDWIMPrint(CommandInterpreter & interpreter)34 CommandObjectDWIMPrint::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 
GetOptions()53 Options *CommandObjectDWIMPrint::GetOptions() { return &m_option_group; }
54 
HandleArgumentCompletion(CompletionRequest & request,OptionElementVector & opt_element_vector)55 void CommandObjectDWIMPrint::HandleArgumentCompletion(
56     CompletionRequest &request, OptionElementVector &opt_element_vector) {
57   lldb_private::CommandCompletions::InvokeCommonCompletionCallbacks(
58       GetCommandInterpreter(), lldb::eVariablePathCompletion, request, nullptr);
59 }
60 
DoExecute(StringRef command,CommandReturnObject & result)61 void 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