1 //===-- CommandObjectExpression.cpp -----------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "CommandObjectExpression.h" 11 12 // C Includes 13 // C++ Includes 14 // Other libraries and framework includes 15 // Project includes 16 #include "CommandObjectThread.h" // For DisplayThreadInfo. 17 #include "lldb/Interpreter/Args.h" 18 #include "lldb/Core/Value.h" 19 #include "lldb/Core/InputReader.h" 20 #include "lldb/Core/ValueObjectVariable.h" 21 #include "lldb/Expression/ClangExpressionVariable.h" 22 #include "lldb/Expression/ClangUserExpression.h" 23 #include "lldb/Expression/ClangFunction.h" 24 #include "lldb/Expression/DWARFExpression.h" 25 #include "lldb/Host/Host.h" 26 #include "lldb/Core/Debugger.h" 27 #include "lldb/Interpreter/CommandInterpreter.h" 28 #include "lldb/Interpreter/CommandReturnObject.h" 29 #include "lldb/Target/ObjCLanguageRuntime.h" 30 #include "lldb/Symbol/ObjectFile.h" 31 #include "lldb/Symbol/Variable.h" 32 #include "lldb/Target/Process.h" 33 #include "lldb/Target/StackFrame.h" 34 #include "lldb/Target/Target.h" 35 #include "llvm/ADT/StringRef.h" 36 37 using namespace lldb; 38 using namespace lldb_private; 39 40 CommandObjectExpression::CommandOptions::CommandOptions () : 41 Options() 42 { 43 // Keep only one place to reset the values to their defaults 44 ResetOptionValues(); 45 } 46 47 48 CommandObjectExpression::CommandOptions::~CommandOptions () 49 { 50 } 51 52 Error 53 CommandObjectExpression::CommandOptions::SetOptionValue (int option_idx, const char *option_arg) 54 { 55 Error error; 56 57 char short_option = (char) m_getopt_table[option_idx].val; 58 59 switch (short_option) 60 { 61 //case 'l': 62 //if (language.SetLanguageFromCString (option_arg) == false) 63 //{ 64 // error.SetErrorStringWithFormat("Invalid language option argument '%s'.\n", option_arg); 65 //} 66 //break; 67 68 case 'g': 69 debug = true; 70 break; 71 72 case 'f': 73 error = Args::StringToFormat(option_arg, format); 74 break; 75 76 case 'o': 77 print_object = true; 78 break; 79 80 case 'u': 81 bool success; 82 unwind_on_error = Args::StringToBoolean(option_arg, true, &success); 83 if (!success) 84 error.SetErrorStringWithFormat("Could not convert \"%s\" to a boolean value.", option_arg); 85 break; 86 87 default: 88 error.SetErrorStringWithFormat("Invalid short option character '%c'.\n", short_option); 89 break; 90 } 91 92 return error; 93 } 94 95 void 96 CommandObjectExpression::CommandOptions::ResetOptionValues () 97 { 98 Options::ResetOptionValues(); 99 //language.Clear(); 100 debug = false; 101 format = eFormatDefault; 102 print_object = false; 103 unwind_on_error = true; 104 show_types = true; 105 show_summary = true; 106 } 107 108 const lldb::OptionDefinition* 109 CommandObjectExpression::CommandOptions::GetDefinitions () 110 { 111 return g_option_table; 112 } 113 114 CommandObjectExpression::CommandObjectExpression (CommandInterpreter &interpreter) : 115 CommandObject (interpreter, 116 "expression", 117 "Evaluate a C/ObjC/C++ expression in the current program context, using variables currently in scope.", 118 NULL), 119 m_expr_line_count (0), 120 m_expr_lines () 121 { 122 SetHelpLong( 123 "Examples: \n\ 124 \n\ 125 expr my_struct->a = my_array[3] \n\ 126 expr -f bin -- (index * 8) + 5 \n\ 127 expr char c[] = \"foo\"; c[0]\n"); 128 129 CommandArgumentEntry arg; 130 CommandArgumentData expression_arg; 131 132 // Define the first (and only) variant of this arg. 133 expression_arg.arg_type = eArgTypeExpression; 134 expression_arg.arg_repetition = eArgRepeatPlain; 135 136 // There is only one variant this argument could be; put it into the argument entry. 137 arg.push_back (expression_arg); 138 139 // Push the data for the first argument into the m_arguments vector. 140 m_arguments.push_back (arg); 141 } 142 143 CommandObjectExpression::~CommandObjectExpression () 144 { 145 } 146 147 Options * 148 CommandObjectExpression::GetOptions () 149 { 150 return &m_options; 151 } 152 153 154 bool 155 CommandObjectExpression::Execute 156 ( 157 Args& command, 158 CommandReturnObject &result 159 ) 160 { 161 return false; 162 } 163 164 165 size_t 166 CommandObjectExpression::MultiLineExpressionCallback 167 ( 168 void *baton, 169 InputReader &reader, 170 lldb::InputReaderAction notification, 171 const char *bytes, 172 size_t bytes_len 173 ) 174 { 175 CommandObjectExpression *cmd_object_expr = (CommandObjectExpression *) baton; 176 177 switch (notification) 178 { 179 case eInputReaderActivate: 180 reader.GetDebugger().GetOutputStream().Printf("%s\n", "Enter expressions, then terminate with an empty line to evaluate:"); 181 // Fall through 182 case eInputReaderReactivate: 183 //if (out_fh) 184 // reader.GetDebugger().GetOutputStream().Printf ("%3u: ", cmd_object_expr->m_expr_line_count); 185 break; 186 187 case eInputReaderDeactivate: 188 break; 189 190 case eInputReaderGotToken: 191 ++cmd_object_expr->m_expr_line_count; 192 if (bytes && bytes_len) 193 { 194 cmd_object_expr->m_expr_lines.append (bytes, bytes_len + 1); 195 } 196 197 if (bytes_len == 0) 198 reader.SetIsDone(true); 199 //else if (out_fh && !reader->IsDone()) 200 // ::fprintf (out_fh, "%3u: ", cmd_object_expr->m_expr_line_count); 201 break; 202 203 case eInputReaderInterrupt: 204 cmd_object_expr->m_expr_lines.clear(); 205 reader.SetIsDone (true); 206 reader.GetDebugger().GetOutputStream().Printf("%s\n", "Expression evaluation cancelled."); 207 break; 208 209 case eInputReaderEndOfFile: 210 reader.SetIsDone (true); 211 break; 212 213 case eInputReaderDone: 214 if (cmd_object_expr->m_expr_lines.size() > 0) 215 { 216 cmd_object_expr->EvaluateExpression (cmd_object_expr->m_expr_lines.c_str(), 217 reader.GetDebugger().GetOutputStream(), 218 reader.GetDebugger().GetErrorStream()); 219 } 220 break; 221 } 222 223 return bytes_len; 224 } 225 226 bool 227 CommandObjectExpression::EvaluateExpression 228 ( 229 const char *expr, 230 Stream &output_stream, 231 Stream &error_stream, 232 CommandReturnObject *result 233 ) 234 { 235 if (m_exe_ctx.target) 236 { 237 lldb::ValueObjectSP result_valobj_sp; 238 239 lldb::ExecutionResults exe_results; 240 241 bool keep_in_memory = true; 242 243 exe_results = m_exe_ctx.target->EvaluateExpression(expr, m_exe_ctx.frame, m_options.unwind_on_error, keep_in_memory, result_valobj_sp); 244 245 if (exe_results == eExecutionInterrupted && !m_options.unwind_on_error) 246 { 247 if (m_exe_ctx.thread) 248 lldb_private::DisplayThreadInfo (m_interpreter, result->GetOutputStream(), m_exe_ctx.thread, false, true); 249 else 250 lldb_private::DisplayThreadsInfo (m_interpreter, &m_exe_ctx, *result, true, true); 251 } 252 253 if (result_valobj_sp) 254 { 255 if (result_valobj_sp->GetError().Success()) 256 { 257 if (m_options.format != eFormatDefault) 258 result_valobj_sp->SetFormat (m_options.format); 259 260 ValueObject::DumpValueObject (output_stream, 261 m_exe_ctx.GetBestExecutionContextScope(), 262 result_valobj_sp.get(), // Variable object to dump 263 result_valobj_sp->GetName().GetCString(),// Root object name 264 0, // Pointer depth to traverse (zero means stop at pointers) 265 0, // Current depth, this is the top most, so zero... 266 UINT32_MAX, // Max depth to go when dumping concrete types, dump everything... 267 m_options.show_types, // Show types when dumping? 268 false, // Show locations of variables, no since this is a host address which we don't care to see 269 m_options.print_object, // Print the objective C object? 270 true, // Scope is already checked. Const results are always in scope. 271 false); // Don't flatten output 272 if (result) 273 result->SetStatus (eReturnStatusSuccessFinishResult); 274 } 275 else 276 { 277 error_stream.PutCString(result_valobj_sp->GetError().AsCString()); 278 if (result) 279 result->SetStatus (eReturnStatusFailed); 280 } 281 } 282 } 283 else 284 { 285 error_stream.Printf ("error: invalid execution context for expression\n"); 286 return false; 287 } 288 289 return true; 290 } 291 292 bool 293 CommandObjectExpression::ExecuteRawCommandString 294 ( 295 const char *command, 296 CommandReturnObject &result 297 ) 298 { 299 m_exe_ctx = m_interpreter.GetDebugger().GetExecutionContext(); 300 301 m_options.ResetOptionValues(); 302 303 const char * expr = NULL; 304 305 if (command[0] == '\0') 306 { 307 m_expr_lines.clear(); 308 m_expr_line_count = 0; 309 310 InputReaderSP reader_sp (new InputReader(m_interpreter.GetDebugger())); 311 if (reader_sp) 312 { 313 Error err (reader_sp->Initialize (CommandObjectExpression::MultiLineExpressionCallback, 314 this, // baton 315 eInputReaderGranularityLine, // token size, to pass to callback function 316 NULL, // end token 317 NULL, // prompt 318 true)); // echo input 319 if (err.Success()) 320 { 321 m_interpreter.GetDebugger().PushInputReader (reader_sp); 322 result.SetStatus (eReturnStatusSuccessFinishNoResult); 323 } 324 else 325 { 326 result.AppendError (err.AsCString()); 327 result.SetStatus (eReturnStatusFailed); 328 } 329 } 330 else 331 { 332 result.AppendError("out of memory"); 333 result.SetStatus (eReturnStatusFailed); 334 } 335 return result.Succeeded(); 336 } 337 338 if (command[0] == '-') 339 { 340 // We have some options and these options MUST end with --. 341 const char *end_options = NULL; 342 const char *s = command; 343 while (s && s[0]) 344 { 345 end_options = ::strstr (s, "--"); 346 if (end_options) 347 { 348 end_options += 2; // Get past the "--" 349 if (::isspace (end_options[0])) 350 { 351 expr = end_options; 352 while (::isspace (*expr)) 353 ++expr; 354 break; 355 } 356 } 357 s = end_options; 358 } 359 360 if (end_options) 361 { 362 Args args (command, end_options - command); 363 if (!ParseOptions (args, result)) 364 return false; 365 } 366 } 367 368 if (expr == NULL) 369 expr = command; 370 371 if (EvaluateExpression (expr, result.GetOutputStream(), result.GetErrorStream(), &result)) 372 return true; 373 374 result.SetStatus (eReturnStatusFailed); 375 return false; 376 } 377 378 lldb::OptionDefinition 379 CommandObjectExpression::CommandOptions::g_option_table[] = 380 { 381 //{ LLDB_OPT_SET_ALL, false, "language", 'l', required_argument, NULL, 0, "[c|c++|objc|objc++]", "Sets the language to use when parsing the expression."}, 382 //{ LLDB_OPT_SET_1, false, "format", 'f', required_argument, NULL, 0, "[ [bool|b] | [bin] | [char|c] | [oct|o] | [dec|i|d|u] | [hex|x] | [float|f] | [cstr|s] ]", "Specify the format that the expression output should use."}, 383 { LLDB_OPT_SET_1, false, "format", 'f', required_argument, NULL, 0, eArgTypeExprFormat, "Specify the format that the expression output should use."}, 384 { LLDB_OPT_SET_2, false, "object-description", 'o', no_argument, NULL, 0, eArgTypeNone, "Print the object description of the value resulting from the expression."}, 385 { LLDB_OPT_SET_ALL, false, "unwind-on-error", 'u', required_argument, NULL, 0, eArgTypeBoolean, "Clean up program state if the expression causes a crash, breakpoint hit or signal."}, 386 { LLDB_OPT_SET_ALL, false, "debug", 'g', no_argument, NULL, 0, eArgTypeNone, "Enable verbose debug logging of the expression parsing and evaluation."}, 387 { LLDB_OPT_SET_ALL, false, "use-ir", 'i', no_argument, NULL, 0, eArgTypeNone, "[Temporary] Instructs the expression evaluator to use IR instead of ASTs."}, 388 { 0, false, NULL, 0, 0, NULL, NULL, eArgTypeNone, NULL } 389 }; 390 391