lldb/source/Commands/CommandObjectDWIMPrint.cpp

   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
  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
  53 Options *CommandObjectDWIMPrint::GetOptions() { return &m_option_group; }
  54
  55 void CommandObjectDWIMPrint::HandleArgumentCompletion(
  56     CompletionRequest &request, OptionElementVector &opt_element_vector) {
  57   lldb_private::CommandCompletions::InvokeCommonCompletionCallbacks(
  58       GetCommandInterpreter(), lldb::eVariablePathCompletion, request, nullptr);
  59 }
  60
  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 }